Guru99

A discussion on automation testing with respect to agile methodology.

sanjay — 2013-05-13T10:55:38+00:00

This post in contributed by Debanjan Banarjee who is an automation expert

In the last few years, ever since the agile methodology came on board with its founders shouting and willing to do away with the mundane and laborious realities of the traditional waterfall model, the impact of the same can be also felt when it comes to automation testing.

In the realm of the traditional process of software testing life cycle, automation testing is normally feasible when the application is stable, steady and the requirement is involving with a real considerable amount of time and in most cases involving a set of very skillful automation expert resources as well as a considerable amount of set-up costs. The basic purpose of automation testing is to reduce costs over long time and to ensure no new defects have been introduced as a result of existing test cases.

Automation testing by the very nature of the technology is not exploratory in nature since the main role of automation testing is saving time and reducing costs. Automation testing is not meant to come up with new and innovative defects. Automation testing aims at mostly conformation of the already existing.

Now by its very definition agile methodology talks about doing away with laborious and tedious documentation so that new and innovative ideas could be implemented and people could interact freely with each other so that more of these innovative and explorative ideas could be implemented.

Thus we could see a contradiction between the basic fundamental philosophies of agile methodologies and automation testing.

So we need to consider certain fundamental points here when it comes to evaluating the use of agile methodologies with respect to the automation testing methods and techniques. Thus we need to consider some fundamental points like time taken for design and coding, validation of the designed scripts with the existing test data and then adoption of the same for testing (whether the tests are of functional or regression purposes) So the real fact of all these events is that in order to perform all these facts, we need to ensure that a considerable amount of time is required for these tasks and in an agile environment where an average sprint takes an average 1-2 weeks to complete and thus it is obviously too difficult to contemplate affording so much time for automating scripts in such an way.

Another significant factor remains here that the type of changes in requirements which come into picture when agile methodology is at play. Agile methodology by it’s own very definition is a sort of technique which is very helpful for responding to quick customer induced change requirements and which thus lends itself well to frequent changes during the overall development of the application.

In contrast automation testing is very useful when it comes to the more stable and less frequent types of requirements. Thus by definition automation testing does not lend itself well to various types of frequent changes in requirements which comes alongside the adoption of any agile methodologies.

The selection of relevant automation tool is also a potentially very important factor when it comes to the adoption of automation testing within the scope of an overall agile methodology. Licensed automation tools for example impose strict security access criterion to different types and levels of users when it comes accessing various important resources belonging to that particular testing automation framework.

In contrast agile methodology emphasizes upon mostly open collaboration and open ended interaction between team members and thus restrictive policies which directly affects how the users would have a negative impact in the overall cohesion within the team and thus may be leading into results which are neither very helpful nor very conducive to the overall success of the project.

Therefore the primary importance of the process should be to ensure that in order to obtain the quality delivery of automation test scripts within a stipulated time as afforded by agile methodology; we need to choose our prospective test cases which would be automated in a more nuanced way such that these automated test scripts lend themselves well for future re-use as well as ensuring that they can be prepared within the proper duration of the allotted time (as required during the agile methodology process).

After consideration of all the above factors we thus can realize that even while adopting agile methodologies, we need to bring into picture the types of tests like for example regression tests (since even during agile testing there is a considerable amount of testing work which is required to put into the job of agile methodologies for ensuring better quality of the overall product)

Now let us look at the most basic situations whereby automation testing can be used and how we can adopt the same towards the realm of agile testing.

Complete Web Application Testing Checklist

support — 2013-04-29T09:23:11+00:00

This post in contributed by Pradeep Agya. Pradeep is a QA Lead in a leading MNC

While testing the web applications, one should consider the below mentioned checklist. The below mentioned checklist is almost applicable for all types of web applications depending on the business requirements.

The web application checklist consists of: -

Usability Testing
Functional Testing
Compatibility Testing
Database Testing
Security Testing
Performance Testing

Now let’s look each checklist in detail:

Usability Testing

What is Usability Testing?

Usability testing is nothing but the User-friendliness check.
In Usability testing, the application flow is tested so that a new user can understand the application easily.
Basically, system navigation is checked in Usability testing.

What is the purpose or Goal of Usability testing?

A Usability test establishes the ease of use and effectiveness of a product using a standard Usability test practices.

Usability Test Scenarios:

Web page content should be correct without any spelling or grammatical errors
All fonts should be same as per the requirements.
All the text should be properly aligned.
All the error messages should be correct without any spelling or grammatical errors and the error message should match with the field label.
Tool tip text should be there for every field.
All the fields should be properly aligned.
Enough space should be provided between field labels, columns, rows, and error messages.
All the buttons should be in a standard format and size.
Home link should be there on every single page.
Disabled fields should be grayed out.
Check for broken links and images.
Confirmation message should be displayed for any kind of update and delete operation.
Check the site on different resolutions (640 x 480, 600x800 etc.?)
Check the end user can run the system without frustration.
Check the tab should work properly.
Scroll bar should appear only if required.
If there is an error message on submit, the information filled by the user should be there.
Title should display on each web page
All fields (Textbox, dropdown, radio button etc) and buttons should be accessible by keyboard shortcuts and the user should be able to perform all operations by using keyboard.
Check if the dropdown data is not truncated due to the field size and also check whether the data is hardcoded or managed via administrator.

Functional Testing:

What is Functional Testing?

Testing the features and operational behavior of a product to ensure they correspond to its specifications.
Testing that ignores the internal mechanism of a system or component and focuses solely on the outputs generated in response to selected inputs and execution conditions.

What is the purpose or Goal of Functional testing?

The goal of Functional testing is to verify whether your product meets the intended functional specifications mentioned in your development documentation.

Functional Test Scenarios:

Test all the mandatory fields should be validated.
Test the asterisk sign should display for all the mandatory fields.
Test the system should not display the error message for optional fields.
Test that leap years are validated correctly & do not cause errors/miscalculations.
Test the numeric fields should not accept the alphabets and proper error message should display.
Test for negative numbers if allowed for numeric fields.
Test division by zero should be handled properly for calculations.
Test the max length of every field to ensure the data is not truncated.
Test the pop up message (“This field is limited to 500 characters) should display if the data reaches the maximum size of the field.
Test that a confirmation message should display for update and delete operations.
Test the amount values should display in currency format.
Test all input fields for special characters.
Test the timeout functionality.
Test the Sorting functionality.
Test the functionality of the buttons available
Test the Privacy Policy & FAQ is clearly defined and should be available for users.
Test if any functionality fails the user gets redirected to the custom error page.
Test all the uploaded documents are opened properly.
Test the user should be able to download the uploaded files.
Test the email functionality of the system.
Test the java script is properly working in different browsers (IE, Firefox, Chrome, safari and Opera).
Test to see what happens if a user deletes cookies while in the site.
Test to see what happens if a user deletes cookies after visiting a site.
Test all the data inside combo/list box is arranged in chronological order.

Compatibility Testing:

What is Compatibility testing?

Comp ability testing is used to determine if your software is compatible with other elements of a system with which it should operate, e.g. Browsers, Operating Systems, or hardware.

What is the purpose or Goal of Compatibility testing?

The purpose of Comp ability testing is to evaluate how well software performs in a particular browser, Operating Systems, hardware or software.

Comp ability Test Scenarios:

Test the website in different browsers (IE, Firefox, Chrome, Safari and Opera) and ensure the website is displaying properly.
Test the HTML version being used is compatible with appropriate browser versions.
Test the images display correctly in different browsers.
Test the fonts are usable in different browsers.
Test the java script code is usable in different browsers.
Test the Animated GIF’s across different browsers.

Tool for Compatibility Testing:

Spoon.net: Spoon.net provides access to thousands of applications (Browsers) without any installs. This tool helps you to test your application on different browsers on one single machine.

Database Testing:

What is Database Testing?

In Database testing backend records are tested which have been inserted through the web or desktop applications. The data which is displaying in the web application should match with the data stored in the Database.

To perform the Database testing, the tester should be aware of the below mentioned points:

The tester should understand the functional requirements, business logic, application flow and database design thoroughly.
The tester should figure out the tables, triggers, store procedures, views and cursors used for the application.
The tester should understand the logic of the triggers, store procedures, views and cursors created.
The tester should figure out the tables which get affected when insert update and delete (DML) operations are performed through the web or desktop applications.

With the help of the above mentioned points, the tester can easily write the test scenarios for Database testing.

Test Scenarios for Database Testing:

Verify the database name: The database name should match with the specifications.
Verify the Tables, columns, column types and defaults: All things should match with the specifications.
Verify whether the column allows a null or not.
Verify the Primary and foreign key of each table.
Verify the Stored Procedure:
Test whether the Stored procedure is installed or not.
Verify the Stored procedure name
Verify the parameter names, types and number of parameters.
Test the parameters if they are required or not.
Test the stored procedure by deleting some parameters
Test when the output is zero, the zero records should be affected.
Test the stored procedure by writing simple SQL queries.
Test whether the stored procedure returns the values
Test the stored procedure with sample input data.
Verify the behavior of each flag in the table.
Verify the data gets properly saved into the database after the each page submission.
Verify the data if the DML (Update, delete and insert) operations are performed.
Check the length of every field: The field length in the back end and front end must be same.
Verify the database names of QA, UAT and production. The names should be unique.
Verify the encrypted data in the database.
Verify the database size. Also test the response time of each query executed.
Verify the data displayed on the front end and make sure it is same in the back end.
Verify the data validity by inserting the invalid data in the database.
Verify the Triggers.

What is Security Testing?

Security Testing involves the test to identify any flaws and gaps from a security point of view.

Test Scenarios for Security Testing:

Verify the web page which contains important data like password, credit card numbers, secret answers for security question etc should be submitted via HTTPS (SSL).
Verify the important information like password, credit card numbers etc should display in encrypted format.
Verify password rules are implemented on all authentication pages like Registration, forgot password, change password.
Verify if the password is changed the user should not be able to login with the old password.
Verify the error messages should not display any important information.
Verify if the user is logged out from the system or user session was expired, the user should not be able to navigate the site.
Verify to access the secured and non secured web pages directly without login.
Verify the “View Source code” option is disabled and should not be visible to the user.
Verify the user account gets locked out if the user is entering the wrong password several times.
Verify the cookies should not store passwords.
Verify if, any functionality is not working, the system should not display any application, server, or database information. Instead, it should display the custom error page.
Verify the SQL injection attacks.
Verify the user roles and their rights. For Example The requestor should not be able to access the admin page.
Verify the important operations are written in log files, and that information should be traceable.
Verify the session values are in an encrypted format in the address bar.
Verify the cookie information is stored in encrypted format.
Verify the application for Brute Force Attacks

What is Performance Testing?

Performance testing is conducted to evaluate the compliance of a system or component with specified performance requirements.

General Test scenarios:

To determine the performance, stability and scalability of an application under different load conditions.
To determine if the current architecture can support the application at peak user levels.
To determine which configuration sizing provides the best performance level.
To identify application and infrastructure bottlenecks.
To determine if the new version of the software adversely had an impact on response time.
To evaluate product and/or hardware to determine if it can handle projected load volumes.

How to do Performance testing? By Manual Testing or by Automation

Practically it is not possible to do the performance testing manually because of some drawbacks like:

More number of resources will be required.
Simultaneous actions are not possible.
Proper system monitoring is not available.
Not easy to perform the repetitive task.

Hence to overcome the above problems we should use Performance testing tool. Below is the list of some popular testing tools.

Apache JMeter
Load Runner
Borland Silk Performer.
Rational Performance Tester
WAPT
NEO LOAD

Alpha Beta Testing - DeMystified

support — 2013-04-02T05:19:22+00:00

What is Alpha Testing ?

Alpha testing is a type of acceptance testing; performed to identify all possible issues/bugs before releasing the product to everyday users or public. The focus of this testing is to simulate real users by using blackbox and whitebox techniques. The aim is to carry out the tasks that a typical user might perform. Alpha testing is carried out in a lab environment and usually the testers are internal employees of the organization. To put it as simple as possible, this kind of testing is called alpha only because it is done early on, near the end of the development of the software, and before beta testing.

What is Beta Testing?

Beta Testing of a product is performed by “real users” of the software application in a “real environment” and can be considered as a form of external user acceptance testing.

Beta version of the software is released to a limited number of end-users of the product to obtain feedback on the product quality. Beta testing reduces product failure risks and provides increased quality of the product through customer validation.

It is the final test before shipping a product to the customers. Direct feedback from customers is a major advantage of Beta Testing. This testing helps to tests the product in real time environment.

Alpha Testing versus Beta testing:

Following are the differences of Alpha and Beta Testing:

Alpha Testing

Beta Testing

Alpha testing performed by Testers who are usually internal employees of the organization

Beta testing is performed by Clients or End Users who are not employees of the organization

Alpha Testing performed at developer’s site

Beta testing is performed at client location or end user of the product

Reliability and security testing are not performed in-depth Alpha Testing

Reliability, Security, Robustness are checked during Beta Testing

Alpha testing involves both the white box and black box techniques

Beta Testing typically uses black box testing

Alpha testing requires lab environment or testing environment

Beta testing doesn’t require any lab environment or testing environment. Software is made available to the public and is said to be real time environment

Long execution cycle may be required for Alpha testing

Only few weeks of execution are required for Beta testing

Critical issues or fixes can be addressed by developers immediately in Alpha testing

Most of the issues or feedback is collected from Beta testing will be implemented in future versions of the product

Alpha testing is to ensure the quality of the product before moving to Beta testing

Beta testing also concentrates on quality of the product, but gathers users input on the product and ensures that the product is ready for real time users.

Types of Beta Testing

There are different types of Beta tests, and they are as follows:

Traditional Beta testing: Product is distributed to the target market, and related data is gathered in all aspects. This data can be used for Product improvement.

Public Beta Testing: Product is publicly released to the outside world via online channels and data can be gathered from anyone. Based on feedback, product improvements can be done. For example, Microsoft conducted the largest of all Beta Tests for its OS -- Windows 8 before officially releasing it.

Technical Beta Testing: Product is released to the internal group of an organization and gather feedback/data from the employees of the organization.

Focused Beta: Product is released to the market for gathering feedback on specific features of the program. For example, important functionality of the software.

Post release Beta: Product is released to the market and data is gathered to make improvements for the future release of the product.

Entry and Exit criteria

Entry Criteria for Alpha testing:

Software requirements document or Business requirements specification
Test Cases for all the requirements
Testing Team with good knowledge about the software application
Test Lab environment setup
QA Build ready for execution
Test Management tool for uploading test cases and logging defects
Traceability Matrix to ensure that each design requirement has alteast one test case that verifies it

Exit Criteria for Alpha testing

All the test cases have been executed and passed.
All severity issues need to be fixed and closed
Delivery of Test summary report
Make sure that no more additional features can be included
Sign off on Alpha testing

Entrance criteria for Beta Testing:

Sign off document on Alpha testing
Beta version of the software should be ready
Environment ready to release the software application to the public
Tool to capture real time faults

Exit Criteria for Beta Testing:

All major and minor issues are closed
Feedback report should be prepared from public
Delivery of Beta test summary report

Phases of Testing

Alpha and Beta tests are typically carried for “off-the shelf” software or product oriented companies. The Phases of Testing for a product company typically varies from a service oriented organization. Following is the testing phase adopted by product firms

Pre-Alpha:- Software is a prototype. UI is complete. But not all features are completed. At this stage software is not published.

Alpha: Software is near its development and is internally tested for bugs/issues

Beta: Software is stable and is released to limited user base. The goal is to get customer feedback on the product and make changes in software accordingly

Release Candidate (RC): Based on the feedback of Beta Test, you make changes to the software and want to test out the bug fixes. At this stage, you do not want to make radical changes in functionality but just check for bugs. RC is also put out to the public

Release: All works, software is released to public.

Note: Above is a standard definition of the Testing stages but in order to garner marketing buzz, companies combine stages like “pre-alpha beta”, “pre-beta” etc.

Advantages & Disadvantages

Advantages Beta Testing

Reduces product failure risk via customer validation.
Beta Testing allows a company to test post-launch infrastructure.
Improves product quality via customer feedback
Cost effective compared to similar data gathering methods
Creates goodwill with customers and increases customer satisfaction

Disadvantages Beta Testing

Test Management is an issue. As compared to other testing types which are usually executed inside a company in a controlled environment, beta testing is executed out in the real world where you seldom have control.
Finding the right beta users and maintaining their participation could be a challenge

Advantages of Alpha Testing:

Provides better view about the reliability of the software at an early stage
Helps simulate real time user behavior and environment.
Detect many showstopper or serious errors
Ability to provide early detection of errors with respect to design and functionality

Disadvantages of Alpha Testing:

In depth functionality cannot be tested as software is still under development stage Sometimes developers and testers are dissatisfied with the results of alpha testing

Myths of Alpha and Beta Testing:

Myth: Alpha and Beta testing are carried out too late in the testing life cycle to merit a benefit

Truth: Alpha and Beta testing help highlight crucial issues with the software application and provide user feedback.

Myth: Same type of testing is done in Alpha and Beta Testing and they are not different scenarios

Truth: Alpha Testing is done in a lab environment, whereas Beta testing is done by real users reporting real problems based on firsthand experience. Both scenarios are remarkably different.

Myth: Beta type of testing is difficult and time consuming

Truth: Beta testing takes time/experience to obtain the most value. But the data/feedback it provides is invaluable.

Myth: Beta testing generates little or no useful data

Truth: A successful Beta Test can generate tons of valuable information which is otherwise difficult to procure in a lab environment.

Conclusion

No matter how many tests you perform, how many bugs you kill, your software is useless if your users do not like it. Beta testing (second Greek alphabet)helps provide authentic feedback of your software from real users.

Alpha testing (first Greek alphabet) helps simulate realtime user environment before the software is sent for Beta Testing and helps shape a stable software candidate eligible for Beta Tests.

Alpha and Beta Testing are indispensable in your testing life cycle.

Back to Software Testing Index Page

Learn Penetration Testing

support — 2013-03-22T04:44:14+00:00

Penetration testing is a type of security testing used to test the insecure areas of the system or application. The goal of this testing is to find all security vulnerabilities that are present in the system being tested. Vulnerability is the risk that an attacker can disrupt or gain authorized access to the system or any data contained within it.

Vulnerabilities are usually introduced by accident during software development and implementation phase. Common vulnerabilities include design errors, configuration errors, software bugs etc.

Need of a Penetration testing:

Penetration is essential in an enterprise because -

Financial sectors like Banks, Investment Banking , Stock Trading Exchanges want their data to be secured , and penetration testing is essential to ensure security
In case if the software system is already hacked and organization wants to determine whether any threats are still present in the system to avoid future hacks.
Proactive Penetration Testing is the best safeguard against hackers

Types of Penetration testing:

The type of penetration test selected usually depends on the scope and whether the organization wants to simulate an attack by an employee, Network Admin (Internal Sources) or by External Sources .There are three types of Penetration testing and they are

Black Box Testing
White Box Penetration testing
Grey Box Penetration Testing

In black box penetration testing, tester has no knowledge about the systems to be tested .He is responsible to collect information about the target network or system.

In a white-box penetration testing, the tester is usually provided with a complete information about the network or systems to be tested including the IP address schema, source code, OS details, etc. This can be considered as a simulation of an attack by any Internal sources (Employees of an Organization).

In a grey box penetration testing, tester is provided with partial knowledge of the system. It can considered an attack by an external hacker who had gained illegitimate access to an organization’s network infrastructure documents.

Steps in Penetration testing:

Following are activities needs to be performed to execute Penetration Test -

Planning phase
1. Scope & Strategy of the assignment is determined
2. Existing security policies, standards are used for defining the scope
Discovery phase
1. Collect as much information as possible about the system including data in the system, user names and even passwords. This is also called as FINGERPRINTING
2. Scan and Probe into the ports
3. Check for vulnerabilities of the system
Attack Phase
1. Find exploits for various vulnerabilities You need necessary security Privileges to exploit the system
Reporting Phase
1. Report must contain detailed findings
2. Risks of vulnerabilities found and their Impact on business
3. Recommendations and solutions, if any

The prime task in penetration testing is to gather system information. There are two ways to gather information -

‘One to one' or 'one to many' model with respect to host: A tester performs techniques in a linear way against either one target host or a logical grouping of target hosts (e.g. a subnet).
'Many to one' or 'many to many' model :The tester utilizes multiple hosts to execute information gathering techniques in a random, rate-limited, and in non-linear.

Tools of Penetration testing:

There is a wide variety of tools that are used in penetration testing and the important tools are:

NMap– This tool is used to do port scanning, OS identification, Trace the route and for Vulnerability scanning.
Nessus- This is traditional network based vulnerabilities tool.
Pass-The-Hash – This tool is mainly used for password cracking.
Cain and Abel– This tool mainly used for Password recovery, Network sniffing, Wireless scanning and VoIP.

Role and Responsibilities of Penetration Testers:

Penetration Testers job is to:

Testers should collect required information from the Organization to enable penetration tests
Find flaws that could allow hackers to attack a target machine
Pen Testers should think & act like real hackers albeit ethically.
Work done by Penetration testers should be reproducible so that it will be easy for developers to fix it
Start date and End date of test execution should be defined in advance.
Tester should be responsible for any loss in the system or information during the testing
Tester should keep data and information confidential

Manual Penetration vs. automated penetration testing:

Manual testing requires expert professionals to run the tests whereas Automated test tools provides clear reports with less experienced professionals
Manual Testing requires excel and other tools to track it , but automation has centralized and standard tools –
In Manual testing, results vary from test to test but not in the case of Automated tests
Memory Cleaning up should be remembered by users , but automated testing will have comprehensive clean ups.

Limitations of Penetration testing:

Penetration Testing cannot find all vulnerabilities in the system .There are limitations of time , budget , scope , skills of Penetration Testers

Following will be side effects when we are doing penetration testing:

Data Loss and Corruption
Down Time
Increase costs

Conclusion:

Testers should act like a real hacker and test the application or system and needs to check whether code is securely written. A penetration test will be effective if there is a well-implemented security policy. Penetration testing policy and methodology should be a place to make penetration testing more effective.

Back to Software Testing Index Page

Accessing Forms in WebDriver

support — 2013-03-04T12:55:48+00:00

In this tutorial , we will learn how to access forms and its elements using Webdriver

Accessing Form Elements

Input Box

Input boxes refer to either of these two types:

Text Fields– text boxes that accept typed values and show them as they are.
Password Fields– text boxes that accept typed values but mask them as a series of special characters (commonly dots and asterisks) to avoid sensitive values to be displayed.

Entering Values in Input Boxes

The sendKeys() method is used to enter values into input boxes.

Deleting Values in Input Boxes

The clear() method is used to delete the text in an input box. This method does not need any parameter. The code snippet below will clear out the text “tutorial” in the User Name text box.

Radio Button

Toggling a radio button on is done using the click() method.

Check Box

Toggling a check box on/off is also done using the click() method.

The code below will click on Facebook’s “Keep me logged in” check box twice and then output the result as TRUE when it is toggled on, and FALSE if it is toggled off.

Links

Links also are accessed by using the click() method.

Consider the below link found in Mercury Tours’ homepage.

You can access this link using linkText() or partialLinkText() together with click(). Either of the two lines below will be able to access the “Register here” link shown above.

Drop-Down Box

Before we can control drop-down boxes, we must do following two things :

Import the package org.openqa.selenium.support.ui.Select
Instantiate the drop-down box as a “Select” object in WebDriver

As an example, go to Mercury Tours’ Registration page (http://newtours.demoaut.com/mercuryregister.php) and notice the “Country” drop-down box there.

Step 1

Import the “Select” package.

Step 2

Declare the drop-down element as an instance of the Select class. In the example below, we named this instance as “drpCountry”.

Step 3

We can now start controlling “drpCountry” by using any of the available Select methods. The sample code below will select the option “ANTARCTICA”.

Selecting Items in a Multiple SELECT element

We can also use the selectByVisibleText() method in selecting multiple options in a multi SELECT element. As an example, we will take http://jsbin.com/osebed/2 as the base URL. It contains a drop-down box that allows multiple selections at a time.

The code below will select the first two options using the selectByVisibleText() method.

Select Methods

The following are the most common methods used on drop-down elements.

Method	Description
selectByVisibleText() and deselectByVisibleText() Example:	Selects/deselects the option that displays the text matching the parameter. Parameter: The exactly displayed text of a particular option
selectByValue() and deselectByValue() Example:	Selects/deselects the option whose “value” attribute matches the specified parameter. Parameter: value of the “value” attribute Remember that not all drop-down options have the same text and “value”, like in the example below.
selectByIndex() and deselectByValue() Example:	Selects/deselects the option at the given index. Parameter: the index of the option to be selected.
isMultiple() Example:	Returns TRUE if the drop-down element allows multiple selections at a time; FALSE if otherwise. Needs parameters needed
deselectAll() Example:	Clears all selected entries. This is only valid when the drop-down element supports multiple selections. No parameters needed

Submitting a Form

The submit() method is used to submit a form. This is an alternative to clicking the form’s submit button.

You can use submit() on any element within the form, not just on the submit button itself.

When submit() is used, WebDriver will look up the DOM to know which form the element belongs to, and then trigger its submit function.

Summary

The table below summarizes the commands to access each type of element discussed above.

Element	Command	Description
Input Box	sendKeys()	used to enter values onto text boxes
Input Box	clear()	used to clear text boxes of its current value
Check Box, Radio Button,	click()	used to toggle the element on/off
Links	click()	used to click on the link and wait for page load to complete before proceeding to the next command.
Drop-Down Box	selectByVisibleText()/ deselectByVisibleText()	selects/deselects an option by its displayed text
	selectByValue()/ deselectByValue()	selects/deselects an option by the value of its “value” attribute
	selectByIndex()/ deselectByIndex()	selects/deselects an option by its index
	isMultiple()	returns TRUE if the drop-down element allows multiple selection at a time; FALSE if otherwise
	deselectAll()	deselects all previously selected options
Submit Button	submit()

WebDriver allows selection of more than one option in a multiple SELECT element.
To control drop-down boxes, you must first import the org.openqa.selenium.support.ui.Select package and then create a Select instance.
You can use the submit() method on any element within the form. WebDriver will automatically trigger the submit function of the form where that element belongs to.

Previous Tutorial Back to Selenium Tutorials Index Page Next Tutorial

First WebDriver Script

support — 2013-03-04T07:09:38+00:00

Using the Java class “myclass” that we created in the previous tutorial, let us try to create a WebDriver script that would:

fetch Mercury Tours’ homepage
verify its title
print out the result of the comparison
close it before ending the entire program.

WebDriver Code

Below is the actual WebDriver code for the logic presented by the scenario above

package mypackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

   public static void main(String[] args) {
        // declaration and instantiation of objects/variables
        WebDriver driver = new FirefoxDriver();
        String baseUrl = "http://newtours.demoaut.com";
        String expectedTitle = "Welcome: Mercury Tours";
        String actualTitle = "";

        // launch Firefox and direct it to the Base URL
        driver.get(baseUrl);

        // get the actual value of the title
        actualTitle = driver.getTitle();

        /*
        * compare the actual title of the page witht the expected one and print
        * the result as "Passed" or "Failed"
        */
        if (actualTitle.contentEquals(expectedTitle)){
            System.out.println("Test Passed!");
        } else {
            System.out.println("Test Failed");
        }

        //close Firefox
        driver.close();

        // exit the program explicitly
        System.exit(0);
   }

}

Explaining the code

Importing Packages

To get started, you need to import following two packages:

org.openqa.selenium.*- contains the WebDriver class needed to instantiate a new browser loaded with a specific driver
org.openqa.selenium.firefox.FirefoxDriver – contains the FirefoxDriver class needed to instantiate a Firefox-specific driver onto the browser instantiated by the WebDriver class

If your test needs more complicated actions such as accessing another class, taking browser screenshots, or manipulating external files, definitely you will need to import more packages.

Instantiating objects and variables

Normally, this is how a driver object is instantiated.

A FirefoxDriver class with no parameters means that the default Firefox profile will be launched by our Java program. The default Firefox profile is similar to launching Firefox in safe mode (no extensions are loaded).

For convenience, we saved the Base URL and the expected title as variables.

Launching a Browser Session

WebDriver’s get() method is used to launch a new browser session and directs it to the URL that you specify as its parameter.

Get the Actual Page Title

The WebDriver class has the getTitle() method that is always used to obtain the page title of the currently loaded page.

Compare the Expected and Actual Values

This portion of the code simply uses a basic Java if-else structure to compare the actual title with the expected one.

Terminating a Browser Session

The “close()” method is used to close the browser window.

Terminating the Entire Program

If you use this command without closing all browser windows first, your whole Java program will end, while leaving browser window open.

Running the Test

There are two ways to execute code in Eclipse IDE.

On Eclipse’s menu bar, click Run > Run.
Press Ctrl+F11 to run the entire code.

If you did everything correctly, Eclipse would output “Test Passed!”

Locating GUI Elements

Locating elements in WebDriver is done by using the “findElement(By.locator())” method. The “locator” part of the code is same as any of the locators previously discussed in the Selenium IDE chapters of these tutoriasl.Infact , it is recommeded you locate GUI elements using IDE and once successfully identified export the code to webdriver.

Here is a sample code that locates an element by its id. Facebook is used as the Base URL.

package mypackage;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
public class myclass {

   public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();
        String baseUrl = "http://www.facebook.com";
        String tagName = "";

        driver.get(baseUrl);
        tagName = driver.findElement(By.id("email")).getTagName();
        System.out.println(tagName);
        driver.close();
        System.exit(0);
   }
}

We used the getTagName() method to extract the tag name of that particular element whose id is “email”. When run, this code should be able to correctly identify the tag name “input” and will print it out on Eclipse’s Console window.

Summary for locating elements

Variation	Description	Sample
By.className	finds elements based on the value of the “class” attribute	findElement(By.className(“someClassName”))
By.cssSelector	finds elements based on the driver’s underlying CSS Selector engine	findElement(By.cssSelector(“input#email”))
By.id	locates elements by the value of their “id” attribute	findElement(By.id(“someId”))
By.linkText	finds a link element by the exact text it displays	findElement(By.linkText(“REGISTRATION”))
By.name	locates elements by the value of the “name” attribute	findElement(By.name(“someName”))
By.partialLinkText	locates elements that contain the given link text	findElement(By.partialLinkText(“REG”))
By.tagName	locates elements by their tag name	findElement(By.tagName(“div”))
By.xpath	locates elements via XPath	findElement(By.xpath(“//html/body/div/table/tbody/tr/td[2]/table/tbody/tr[4]/td/table/tbody/tr/td[2]/table/tbody/tr[2]/td[3]/form/table/tbody/tr[5]”))

Note on Using findElement(By.cssSelector())

By.cssSelector() does not support the “contains” feature. Consider the Selenium IDE code below -

In Selenium IDE above, the entire test passed. However in the WebDriver script below, the same test generated an error because WebDriver does not support the “contains” keyword when used in the By.cssSelector() method.

Common Commands

Instantiating Web Elements

Instead of using the long “driver.findElement(By.locator())” syntax every time you will access a particular element, we can instantiate a WebElement object for it. The WebElement class is contained in the “org.openqa.selenium.*” package.

Clicking on an Element

Clicking is perhaps the most common way of interacting with web elements. The click() method is used to simulate the clicking of any element. The following example shows how click() was used to click on Mercury Tours’ “Sign-In” button.

Following things must be noted when using the click() method.

It does not take any parameter/argument.
The method automatically waits for a new page to load if applicable.
The element to be clicked-on, must be visible (height and width must not be equal to zero).

Get Commands

Get commands fetch various important information about the page/element. Here are some important “get” commands you must be familiar with.

get() Sample usage:	It automatically opens a new browser window and fetches the page that you specify inside its parentheses. It is the counterpart of Selenium IDE’s “open” command. The parameter must be a String object.
getTitle() Sample usage:	Needs no parameters Fetches the title of the current page Leading and trailing white spaces are trimmed Returns a null string if the page has no title
getPageSource() Sample usage:	Needs no parameters Returns the source code of the page as a String value
getCurrentUrl() Sample usage:	Needs no parameters Fetches the string representing the current URL that the browser is looking at
getText() Sample usage:	Fetches the inner text of the element that you specify

Navigate commands

These commands allow you to refresh,go-into and switch back and forth between different web pages.

navigate().to() Sample usage:	It automatically opens a new browser window and fetches the page that you specify inside its parentheses. It does exactly the same thing as the get() method.
navigate().refresh() Sample usage:	Needs no parameters. It refreshes the current page.
navigate().back() Sample usage:	Needs no parameters Takes you back by one page on the browser’s history.
navigate().forward() Sample usage:	Needs no parameters Takes you forward by one page on the browser’s history.

Closing and Quitting Browser Windows

close()

Sample usage:

Needs no parameters
It closes only the browser window that WebDriver is currently controlling.

quit()

Sample usage:

Needs no parameters
It closes all windows that WebDriver has opened.

To clearly illustrate the difference between close() and quit(), try to execute the code below. It uses a webpage that automatically pops up a window upon page load and opens up another after exiting.

Notice that only the parent browser window was closed and not the two pop-up windows.

But if you use quit(), all windows will be closed – not just the parent one. Try running the code below and you will notice that the two pop-ups above will automatically be closed as well.

package mypackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

   public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();

        driver.get("http://www.popuptest.com/popuptest2.html");
        driver.quit(); // using QUIT all windows will close

   }
}

Switching Between Frames

To access GUI elements in a Frame, we should first direct WebDriver to focus on the frame or pop-up window first before we can access elements within them. Let us take, for example, the web page http://selenium.googlecode.com/svn/trunk/docs/api/java/index.html

This page has 3 frames whose “name” attributes are indicated above. We wish to access the “Deprecated” link encircled above in yellow. In order to do that, we must first instruct WebDriver to switch to the “classFrame” frame using the “switchTo().frame()” method. We will use the name attribute of the frame as the parameter for the “frame()” part.

package mypackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

   public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();

        driver.get("http://selenium.googlecode.com/svn/trunk/docs/api/java/index.html");
        driver.switchTo().frame("classFrame");
        driver.findElement(By.linkText("Deprecated")).click();
        driver.quit();

   }
}

After executing this code, you will see that the “classFrame” frame is taken to the “Deprecated API” page, meaning that our code was successfully able to access the “Deprecated” link.

Switching Between Pop-up Windows

WebDriver allows pop-up windows like alerts to be displayed, unlike in Selenium IDE. To access the elements within the alert (such as the message it contains), we must use the “switchTo().alert()” method. In the code below, we will use this method to access the alert box and then retrieve its message using the “getText()” method, and then automatically close the alert box using the “switchTo().alert().accept()” method.

First, head over to http://jsbin.com/usidix/1 and manually click the “Go!” button there and see for yourself the message text.

Lets see the WebDriver code to do this-

package mypackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

   public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();
        String alertMessage = "";

        driver.get("http://jsbin.com/usidix/1");
        driver.findElement(By.cssSelector("input[value=\"Go!\"]")).click();
        alertMessage = driver.switchTo().alert().getText();
        driver.switchTo().alert().accept();

        System.out.println(alertMessage);
        driver.quit();

   }
}

On the Eclipse console, notice that the printed alert message is:

Waits

There are two kinds of waits.

Implicit wait – used to set the default waiting time throughout the program
Explicit wait – used to set the waiting time for a particular instance only

Implicit Wait

It is simpler to code than Explicit Waits.
It is usually declared in the instantiation part of the code.
You will only need one additional package to import.

To start using an implicit wait, you would have to import this package into your code.

Then on the instantiation part of your code, add this.

Explicit Wait

Explicit waits are done using the WebDriverWait and ExpectedCondition classes. For the following example, we shall wait up to 10 seconds for an element whose id is “username” to become visible before proceeding to the next command. Here are the steps.

Step 1

Import these two packages:

Step 2

Declare a WebDriverWait variable. In this example, we will use “myWaitVar” as the name of the variable.

Step 3

Use myWaitVar with ExpectedConditions on portions where you need the explicit wait to occur. In this case, we will use explicit wait on the “username” (Mercury Tours HomePage) input before we type the text “tutorial” onto it.

Conditions

Following methods are used in conditional and looping operations --

isEnabled() is used when you want to verify whether a certain element is enabled or not before executing a command.

isDisplayed() is used when you want to verify whether a certain element is displayed or not before executing a command.

isSelected() is used when you want to verify whether a certain check box, radio button, or option in a drop-down box is selected. It does not work on other elements.

Using ExpectedConditions

The ExpectedConditions class offers a wider set of conditions that you can use in conjunction with WebDriverWait’s until() method.

Below are some of the most common ExpectedConditions methods.

alertIsPresent() – waits until an alert box is displayed.

elementToBeClickable() – waits until an element is visible and, at the same time, enabled. The sample code below will wait until the element with id=”username” to become visible and enabled first before assigning that element as a WebElement variable named “txtUserName”.

frameToBeAvailableAndSwitchToIt() – waits until the given frame is already available, and then automatically switches to it.

Catching Exceptions

When using isEnabled(), isDisplayed(), and isSelected(), WebDriver assumes that the element already exists on the page. Otherwise, it will throw a NoSuchElementException. To avoid this, we should use a try-catch block so that the program will not be interrupted.

WebElement txtbox_username = driver.findElement(By.id("username"));
try{
        if(txtbox_username.isEnabled()){
            txtbox_username.sendKeys("tutorial");
        }
}

catch(NoSuchElementException nsee){
System.out.println(nsee.toString());
}

If you use explicit waits, the type of exception that you should catch is the “TimeoutException”.

Summary

To start using the WebDriver API, you must import at least these two packages.
org.openqa.selenium.*
org.openqa.selenium.firefox.FirefoxDriver
The get() method is the equivalent of Selenium IDE’s “open” command.
Locating elements in WebDriver is done by using the findElement(By()) method.
The following are the available options for locating elements in WebDriver:
By.className
By.cssSelector
By.id
By.linkText
By.name
By.partialLinkText
By.tagName
By.xpath
TheBy.cssSelector() does not support the “contains” feature.
You can instantiate an element using the WebElement class.
Clicking on an element is done by using the click() method.
WebDriver provides these useful get commands:
get()
getTitle()
getPageSource()
getCurrentUrl()
getText()
WebDriver provides these useful navigation commands
navigate().forward()
navigate().back()
navigate().to()
navigate().refresh()
The close() and quit() methods are used to close browser windows. Close() is used to close a single window; while quit() is used to close all windows associated to the parent window that the WebDriver object was controlling.
The switchTo().frame() and switchTo().alert() methods are used to direct WebDriver’s focus onto a frame or alert, respectively.
Implicit waits are used to set the waiting time throughout the program, while explicit waits are used only on specific portions.
You can use the isEnabled(), isDisplayed(),isSelected(), and a combination of WebDriverWait and ExpectedConditions methods when verifying the state of an element. However, they do not verify if the element exists.
When isEnabled(), isDisplayed(),or isSelected() was called while the element was not existing, WebDriver will throw a NoSuchElementException.
When WebDriverWait and ExpectedConditions methods were called while the element was not existing, WebDriver would throw a TimeoutException.

Previous Tutorial Back to Selenium Tutorials Index Page Next Tutorial

Keyboard Mouse Events , Uploading Files - Webdriver

support — 2013-03-02T09:45:44+00:00

In this tutorial we will learn handling keyboard and mouse in Webdriver and deal with file uploads and downloads

Handling Keyboard & Mouse Events

Handling special keyboard and mouse events are done using the Advanced User Interactions API. It contains the Actions and the Action classes that are needed when executing these events. The following are the most commonly used keyboard and mouse events provided by the Actions class.

Method	Description
clickAndHold()	Clicks (without releasing) at the current mouse location.
contextClick()	Performs a context-click at the current mouse location.
doubleClick()	Performs a double-click at the current mouse location.
dragAndDrop(source, target)	Performs click-and-hold at the location of the source element, moves to the location of the target element, then releases the mouse. Parameters: source- element to emulate button down at. target- element to move to and release the mouse at.
dragAndDropBy(source, x-offset, y-offset)	Performs click-and-hold at the location of the source element, moves by a given offset, then releases the mouse. Parameters: source- element to emulate button down at. xOffset- horizontal move offset. yOffset- vertical move offset.
keyDown(modifier_key)	Performs a modifier key press. Does not release the modifier key - subsequent interactions may assume it's kept pressed. Parameters: modifier_key – any of the modifier keys (Keys.ALT, Keys.SHIFT, or Keys.CONTROL)
keyUp(modifier _key)	Performs a key release. Parameters: modifier_key – any of the modifier keys (Keys.ALT, Keys.SHIFT, or Keys.CONTROL)
moveByOffset(x-offset, y-offset)	Moves the mouse from its current position (or 0,0) by the given offset. Parameters: x-offset- horizontal offset. A negative value means moving the mouse left. y-offset- vertical offset. A negative value means moving the mouse up.
moveToElement(toElement)	Moves the mouse to the middle of the element. Parameters: toElement- element to move to.
release()	Releases the depressed left mouse button at the current mouse location
sendKeys(onElement, charsequence)	Sends a series of keystrokes onto the element. Parameters: onElement - element that will receive the keystrokes, usually a text field charsequence – any string value representing the sequence of keystrokes to be sent

In the following example, we shall use the moveToElement() method to mouse-over on one Mercury Tours’ table rows. See the example below.

The cell shown above is a portion of a <TR> element. If not hovered, its color is #FFC455 (orange). After hovering, the cell’s color becomes transparent. It becomes the same color as the blue background of the whole orange table.

Step 1

Import the Actions and Action classes.

Step 2

Instantiate a new Actions object.

Step 3

Instantiate an Action using the Actions object in step 2.

In this case, we are going to use the moveToElement() method because we are simply going to mouse-over the “Home” link. The build() method is always the final method used so that all the listed actions will be compiled into a single step.

Step 4

Use the perform() method when executing the Action object we designed in Step 3.

Below is the whole WebDriver code to check the background color of the <TR> element before and after the mouse-over.

package mypackage;

import org.openqa.selenium.*;

import org.openqa.selenium.firefox.FirefoxDriver;

import org.openqa.selenium.interactions.Action;

import org.openqa.selenium.interactions.Actions;

public class myclass {

public static void main(String[] args) {

String baseUrl = "http://newtours.demoaut.com/";

WebDriver driver = new FirefoxDriver();

driver.get(baseUrl);

WebElement link_Home = driver.findElement(By.linkText("Home"));

WebElement td_Home = driver

.findElement(By

.xpath("//html/body/div"

+ "/table/tbody/tr/td"

+ "/table/tbody/tr"));

Actions builder = new Actions(driver);

Action mouseOverHome = builder

.moveToElement(link_Home)

.build();

String bgColor = td_Home.getCssValue("background-color");

System.out.println("Before hover: " + bgColor);

mouseOverHome.perform();

bgColor = td_Home.getCssValue("background-color");

System.out.println("After hover: " + bgColor);

driver.quit();

}

The output below clearly states that the background color became transparent after the mouse-over.

Building a Series of Multiple Actions

You can build a series of actions using the Action and Actions classes. Just remember to close the series with the build() method. Consider the sample code below.

Uploading Files

For this section, we will use http://www.megafileupload.com/ as our test application. This site easily allows any visitor to upload and download files without requiring them to sign up.

Uploading files in WebDriver is done by simply using the sendKeys() method on the file-select input field to enter the path to the file to be uploaded.

Let’s say we wish to upload the file “C:\newhtml.html”. Our WebDriver code should be like the one shown below.

package mypackage;

import org.openqa.selenium.*;

import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

public static void main(String[] args) {

String baseUrl = "http://www.megafileupload.com/";

WebDriver driver = new FirefoxDriver();

driver.get(baseUrl);

WebElement uploadElement = driver.findElement(By.id("uploadfile_0"));

// enter the file path onto the file-selection input field

uploadElement.sendKeys("C:\\newhtml.html");

// check the "I accept the terms of service" check box

driver.findElement(By.id("terms")).click();

// click the "UploadFile" button

driver.findElement(By.name("send")).click();

}

After running this script, you should be able to upload the file successfully and you should get a message similar to this.

Remember following two things when uploading files in WebDriver

There is no need to simulate the clicking of the “Browse” button. WebDriver automatically enters the file path onto the file-selection text box of the <input type=”file”> element
When setting the file path in your Java IDE, use the proper escape character for the back-slash.

Downloading Files

WebDriver has no capability to access the Download dialog boxespresented by browsers when you click on a download link or button. However, we can bypass these dialog boxes using a separate program called “wget”.

What is Wget?

Wget is a small and easy-to-use command-line program used to automate downloads. Basically, we will access Wget from our WebDriver script to perform the download process.

Setting up Wget

Step 1

In your C Drive, create a new folder and name it as “Wget”.

Download wget.exe here and place it in the Wget folder you created from the step above.

Step 2

Bring up the System Properties window by pressing Win + Pause on your keyboard.

Click on “Advanced System Settings”.

Click on the “Environment Variables”.

Step 3

In the Environment Variables dialog box, in the “System variables” section, scroll down the list until you find “Path” and then double-click it.

Step 4

In the “Variable value” text box, add the new path “C:\Wget\”. Just be sure that there is a semi-colon separating this new entry from the preexisting values.

Step 5

Click OK on all dialog boxes.

Launch the command prompt and type the command “wget”. You should get the following response.

Using WebDriver and Wget

In the following example, we will use WebDriver and wget to download a popular chat software called Yahoo Messenger. Our base URL shall be http://messenger.yahoo.com/.

Step 1

Import the “java.io.IOException” package because we will have to catch an IOException later in Step 4.

Step 2

Use getCssAttribute() to obtain the “href” value of the download link and save it as a String variable. In this case, we named the variable as “sourceLocation”.

Step 3

Set-up the syntax for wget using the following command.

Step 4

Initiate the download process by calling wget from our WebDriver code.

To sum it all up, your WebDriver code could look like the one shown below.

package mypackage;

import java.io.IOException;

import org.openqa.selenium.*;

import org.openqa.selenium.firefox.FirefoxDriver;

public class myclass {

public static void main(String[] args) {

String baseUrl = "http://messenger.yahoo.com/";

WebDriver driver = new FirefoxDriver();

driver.get(baseUrl);

WebElement downloadButton = driver.findElement(By

.id("messenger-download"));

String sourceLocation = downloadButton.getAttribute("href");

String wget_command = "cmd /c wget -P c: " + sourceLocation;

try {

Process exec = Runtime.getRuntime().exec(wget_command);

int exitVal = exec.waitFor();

System.out.println("Exit value: " + exitVal);

} catch (InterruptedException | IOException ex) {

System.out.println(ex.toString());

}

driver.quit();

}

After executing this code, check your C drive and verify that the Yahoo Messenger installer was successfully downloaded there.

Summary

Handling special keyboard and mouse events are done using the AdvancedUserInteractions API.
Uploading files in WebDriver is done by simply using the sendKeys() method on the file-select input field to enter the path to the file to be uploaded.
WebDriver cannot automate downloading of files on its own.
The eaasiest way to download files using WebDriver is to use Wget.

Previous Tutorial Back to Selenium Tutorials Index Page Next Tutorial

Accessing Links & Tables - Selenium Webdriver

support — 2013-03-02T08:28:36+00:00

In this tutorial, we are going to learn about accessing links & Tables using Webdriver

Accessing Links

Links Matching a Criterion

Links can be accessed using an exact or partial match of their link text. The examples below provide scenarios where multiple matches would exist, and would explain how WebDriver would deal with them.

Exact Match

Accessing links using their exact link text is done through the By.linkText() method. However, if there are two links that have the very same link text, this method will only access the first one. Consider the HTML code below

When you try to run the WebDriver code below, you will be accessing the first “click here” link

As a result, you will automatically be taken to Google.

Partial Match

Accessing links using a portion of their link text is done using the By.partialLinkText() method. If you specify a partial link text that has multiple matches, only the first match will be accessed. Consider the HTML code below.

When you execute the WebDriver code below, you will still be taken to Google.

Case-sensitivity

The parameters for By.linkText() and By.partialLinkText() are both case-sensitive, meaning that capitalization matters. For example, in Mercury Tours’ homepage, there are two links that contain the text “egis” – one is the “REGISTER” link found at the top menu, and the other is the “Register here” link found at the lower right portion of the page.

Though both links contain the character sequence “egis”, the "By.partialLinkText()" method will access these two links separately depending on capitilization of the characters. See the sample code below.

All Links

One of the common procedures in web testing is to test if all the links present within the page are working. This can be conveniently done using a combination of the Java for-each loop and the By.tagName(“a”) method. The WebDriver code below checks each link from the Mercury Tours homepage to determine those that are working and those that are still under construction.

package practice_webdriver;

import java.util.List;

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.*;

import org.openqa.selenium.firefox.FirefoxDriver;

import org.openqa.selenium.support.ui.ExpectedConditions;

import org.openqa.selenium.support.ui.WebDriverWait;

public class AllLinks {

public static void main(String[] args) {

String baseUrl = "http://newtours.demoaut.com/";

WebDriver driver = new FirefoxDriver();

String underConsTitle = "Under Construction: Mercury Tours";

driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);

driver.get(baseUrl);

List<WebElement> linkElements = driver.findElements(By.tagName("a"));

String[] linkTexts = new String[linkElements.size()];

int i = 0;

//extract the link texts of each link element

for (WebElement e : linkElements) {

linkTexts[i] = e.getText();

i++;

}

//test each link

for (String t : linkTexts) {

driver.findElement(By.linkText(t)).click();

if (driver.getTitle().equals(underConsTitle)) {

System.out.println("\"" + t + "\""

+ " is under construction.");

} else {

System.out.println("\"" + t + "\""

+ " is working.");

}

driver.navigate().back();

}

driver.quit();

}

The output should be similar to the one indicated below.

Links Outside and Inside a Block

The latest HTML5 standard allows the <a> tags to be placed inside and outside of block-level tags like <div>, <p>, or <h1>. The "By.linkText()" and "By.partialLinkText()" methods can access a link located outside and inside these block-level elements. Consider the HTML code below.

The WebDriver code below accesses both of these links using By.partialLinkText() method.

The output above confirms that both links were accessed successfully because their respective page titles were retrieved correctly.

Accessing Image Links

Image links are images that act as references to other sites or sections within the same page. Since they are images, we cannot use the By.linkText() and By.partialLinkText() methods because image links basically have no link texts at all. In this case, we should resort to using either By.cssSelector or By.xpath. The first method is more preferred because of its simplicity.

In the example below, we will access the “Facebook” logo on the upper left portion of Facebook’s Password Recovery page.

We will use By.cssSelector and the element’s “title” attribute to access the image link. And then we will verify if we are taken to Facebook’s homepage.

package practice_webdriver;

import org.openqa.selenium.*;

import org.openqa.selenium.firefox.FirefoxDriver;

public class ImageLink {

public static void main(String[] args) {

String baseUrl = "https://www.facebook.com/login/identify?ctx=recover";

WebDriver driver = new FirefoxDriver();

driver.get(baseUrl);

//click on the "Facebook" logo on the upper left portion

driver.findElement(By.cssSelector("a[title=\"Go to Facebook Home\"]")).click();

//verify that we are now back on Facebook's homepage

if (driver.getTitle().equals("Welcome to Facebook - Log In, Sign Up or Learn More")) {

System.out.println("We are back at Facebook's homepage");

} else {

System.out.println("We are NOT in Facebook's homepage");

}

driver.quit();

}

Result

Reading a Table

There are times when we need to access elements (usually texts) that are within HTML tables. However, it is very seldom for a web designer to provide an id or name attribute to a certain cell in the table. Therefore, we cannot use the usual methods such as “By.id()”, “By.name()”, or “By.cssSelector()”. In this case, the most reliable option is to access them using the “By.xpath()” method.

XPath Syntax

Consider the HTML code below.

We will use XPath to get the inner text of the cell containing the text “fourth cell”.

Step 1 – Set the Parent Element (table)

XPath locators in WebDriver always start with a double forward slash “//” and then followed by the parent element. Since we are dealing with tables, the parent element should always be the <table> tag. The first portion of our XPath locator should therefore start with “//table”.

Step 2 – Add the child elements

The element immediately under <table> is <tbody> so we can say that <tbody> is the “child” of <table>. And also, <table> is the “parent” of <tbody>. All child elements in XPath are placed to the right of their parent element, separated with one forward slash “/” like the code shown below.

Step 3 – Add Predicates

The <tbody> element contains two <tr> tags. We can now say that these two <tr> tags are “children” of <tbody>. Consequently, we can say that <tbody> is the parent of both the <tr> elements.

Another thing we can conclude is that the two <tr> elements are siblings. Siblings refer to child elements having the same parent.

To get to the <td> we wish to access (the one with the text “fourth cell”), we must first access the second <tr> and not the first. If we simply write “//table/tbody/tr”, then we will be accessing the first <tr> tag.

So, how do we access the second <tr> then? The answer to this is to use Predicates.

Predicates are numbers or HTML attributes enclosed in a pair of square brackets “[ ]” that distinguish a child element from its siblings. Since the <tr> we need to access is the second one, we shall use “[2]” as the predicate.

If we won’t use any predicate, XPath will access the first sibling. Therefore, we can access the first <tr> using either of these XPath codes.

Step 4 – Add the Succeeding Child Elements Using the Appropriate Predicates

The next element we need to access is the second <td>. Applying the principles we have learned from steps 2 and 3, we will finalize our XPath code to be like the one shown below.

Now that we have the correct XPath locator, we can already access the cell that we wanted to and obtain its inner text using the code below. It assumes that you have saved the HTML code above as “newhtml.html” within your C Drive.

Accessing Nested Tables

The same principles discussed above applies to nested tables. Nested tables are tables located within another table. An example is shown below.

To access the cell with the text “4-5-6” using the “//parent/child” and predicate concepts from the previous section, we should be able to come up with the XPath code below.

The WebDriver code below should be able to retrieve the inner text of the cell which we are accessing.

The output below confirms that the inner table was successfully accessed.

Using Attributes as Predicates

If the element is written deep within the HTML code such that the number to use for the predicate is very difficult to determine, we can use that element’s unique attribute instead.

In the example below, the “New York to Chicago” cell is located deep into Mercury Tours homepage’s HTML code.

In this case, we can use the table’s unique attribute (width=”270”) as the predicate. Attributes are used as predicates by prefixing them with the @ symbol. In the example above, the “New York to Chicago” cell is located in the first <td> of the fourth <tr>, and so our XPath should be as shown below.

Remember that when we put the XPath code in Java, we should use the escape character backward slash “\” for the double quotation marks on both sides of “270” so that the string argument of By.xpath() will not be terminated prematurely.

We are now ready to access that cell using the code below.

Shortcut: Use Firebug

If the number or attribute of an element is extremely difficult or impossible to obtain, the quickest way to generate the XPath code is thru Firebug.

Consider the example below from Mercury Tours homepage.

Step 1

Use Firebug to obtain the XPath code.

Step 2

Look for the first “table” parent element and delete everything to the left of it.

Step 3

Prefix the remaining portion of the code with double forward slash “//” and copy it over to your WebDriver code.

The WebDriver code below will be able to successfully retrieve the inner text of the element we are accessing.

Summary

Accessing links using their exact match is done using By.linkText() method.
Accessing links using their partial match is done using By.partialLinkText() method.
If there are multiple matches, By.linkText() and By.partialLinkText() will only select the first match.
Pattern matching using By.linkText() and By.partialLinkText() is case-sensitive.
The By.tagName("a") method is used to fetch all links within a page.
Links can be accessed by the By.linkText() and By.partialLinkText() whether they are inside or outside block-level elements.
Accessing image links are done using By.cssSelector() and By.xpath() methods.
By.xpath() is commonly used to access table elements.

Previous Tutorial Back to Selenium Tutorials Index Page Next Tutorial

All about TestNG and Selenium

support — 2013-03-01T09:23:35+00:00

What is TestNG?

So far we had been doing Selenium tests without generating a proper format for the test results. From this point on, we shall tackle how to make these reports using a test framework called TestNG.

TestNG is a testing framework that overcomes the limitations of another popular testing framework called JUnit. The “NG” means “Next Generation”. Most Selenium users use this more than JUnit because of its advantages. There are so many features of TestNG, but we will only focus on the most important ones that we can use in Selenium.

Advantages of TestNG over JUnit

There are three major advantages of TestNG over JUnit:

Annotations are easier to understand
Test cases can be grouped more easily
Parallel testing is possible

Annotations in TestNG are lines of code that can control how the method below them will be executed. They are always preceded by the @ symbol. A very early and quick example is the one shown below.

Annotations will be discussed later in the section named “Annotations used in TestNG”, so it is perfectly ok if you do not understand the above example just yet. It is just important to note for now that annotations in TestNG are easier to code and understand than in JUnit.

The ability to run tests in parallel is available in TestNG but not in JUnit, so it is the more preferred framework of testers using Selenium Grid.

Why do we need TestNG in Selenium?

TestNG can generate reports based on our Selenium test results.

WebDriver has no native mechanism for generating reports.
TestNG can generate the report in a readable format like the one shown below.

TestNG simplifies the way the tests are coded

There is no more need for a static main method in our tests. The sequence of actions is regulated by easy-to-understand annotations that do not require methods to be static.

Uncaught exceptions are automatically handled by TestNG without terminating the test prematurely. These exceptions are reported as failed steps in the report.

Installing TestNG in Eclipse

Step 1

Launch Eclipse.
On the menu bar, click Help.
Choose the “Install New Software…” option.

Step 2

In the Install dialog box, click the Add button

Step 3

In “Name”, type TestNG.
In “Location”, type http://beust.com/eclipse.
Click OK

Step 4

Notice that “TestNG - http://beust.com/eclipse” was populated onto the “Work with:” textbox.
Check the “TestNG” check box as shown below, then click Next.

Step 5

Click Next again on the succeeding dialog box until you reach the License Agreement dialog.
Click “I accept the terms of the license agreement” then click Finish.

Step 6

Wait for the installation to finish

If you encounter a Security warning, just click OK

Step 7

When Eclipse prompts you for a restart, just click Yes.

Step 8

After restart, verify if TestNG was indeed successfully installed. Click Window > Preferences and see if TestNG is included on the Preferences list.

First test case using annotations

Before we create a test case, we should first setup a new TestNG Project in Eclipse and name it as “FirstTestNGProject”.

Setting up a new TestNG Project

Step 1

Click File > New > Java Project

Step 2

Type “FirstTestNGProject” as the Project Name then click Next.

Step 3

We will now start to import the TestNG Libraries onto our project. Click on the “Libraries” tab, and then “Add Library…”

Step 4

On the Add Library dialog, choose “TestNG” and click Next.

Step 5

Click Finish.

You should notice that TestNG is included on the Libraries list.

Step 6

We will now add the JAR files that contain the Selenium API. These files are found in the Java client driver that we downloaded from http://docs.seleniumhq.org/download/ when we were installing Selenium and Eclipse in the previous chapters.

Then, navigate to where you have placed the Selenium JAR files.

After adding the external JARs, your screen should look like this.

Step 7

Click Finish and verify that our FirstTestNGProject is visible on Eclipse’s Package Explorer window.

Creating a New TestNG Test File

Now that we are done setting up our project, let us create a new TestNG file.

Step 1

Right-click on the “src” package folder then choose New > Other…

Step 2

Click on the TestNG folder and select the “TestNG class” option. Click Next.

Step 3

Type the values indicated below on the appropriate input boxes and click Finish. Notice that we have named our Java file as “FirstTestNGFile”.

Eclipse should automatically create the template for our TestNG file shown below.

Coding Our First Test Case

Let us now create our first test case that will check if Mercury Tours’ homepage is correct. Type your code as shown below.

Notice the following.

TestNG does not require you to have a main() method.
Methods need not be static.
We used the @Test annotation. @Test is used to tell that the method under it is a test case. In this case, we have set the verifyHomepageTitle() method to be our test case so we placed an ‘@Test’ annotation above it.
Since we use annotations in TestNG, we needed to import the package org.testng.annotations.*.
We used the Assert class. The Assert class is used to conduct verification operations in TestNG. To use it, we need to import the org.testng.Assert package.

You may have multiple test cases (therefore, multiple @Test annotations) in a single TestNG file. This will be tackled in more detail later in the section “Annotations used in TestNG”.

Running the Test

To run the test, simply run the file in Eclipse as you normally do. Eclipse will provide two outputs – one in the Console window and the other on the TestNG Results window.

Checking reports created by TestNG

The Console window in Eclipse gives a text-based report of our test case results while the TestNG Results window gives us a graphical one.

Generating HTML Reports

TestNG has the ability to generate reports in HTML format.

Step 1

After running our FirstTestNGFile that we created in the previous section, right-click the project name (FirstTestNGProject) in the Project Explorer window then click on the “Refresh” option.

Step 2

Notice that a “test-output” folder was created. Expand it and look for an index.html file. This HTML file is a report of the results of the most recent test run.

Step 3

Double-click on that index.html file to open it within Eclipse’s built-in web browser. You can refresh this page any time after you rerun your test by simply pressing F5 just like in ordinary web browsers.

Annotations used in TestNG

In the previous section, you have been introduced to the @Test annotation. Now, we shall be studying more advanced annotations and their usages.

Multiple Test Cases

We can use multiple @Test annotations in a single TestNG file. By default, methods annotated by @Test are executed alphabetically. See the code below. Though the methods c_test, a_test, and b_test are not arranged alphabetically in the code, they will be executed as such.

Run this code and on the generated index.html page, click “Chronological view”.

Parameters

If you want the methods to be executed in a different order, use the parameter “priority”. Parameters are keywords that modify the annotation’s function.

Parameters require you to assign a value to them. You do.this by placing a “=” next to them, and then followed by the value.
Parameters are enclosed in a pair of parentheses which are placed right after the annotation like the code snippet shown below.

TestNG will execute the @Test annotation with the lowest priority value up to the largest. There is no need for your priority values to be consecutive.

The TestNG HTML report will confirm that the methods were executed based on the ascending value of priority.

Multiple Parameters

Aside from “priority”, @Test has another parameter called “alwaysRun” which can only be set to either “true” or “false”. To use two or more parameters in a single annotation, separate them with a comma such as the one shown below.

@BeforeTest and @AfterTest

@BeforeTest	methods under this annotation will be executed prior to the first test case in the TestNG file.
@AfterTest	methods under this annotation will be executed after all test cases in the TestNG file are executed.

Consider the code below.

Applying the logic presented by the table and the code above, we can predict that the sequence by which methods will be executed is:

1^st – launchBrowser()
2^nd – verifyHomepageTitle()
3^rd – terminateBrowser()

The placement of the annotation blocks can be interchanged without affecting the chronological order by which they will be executed. For example, try to rearrange the annotation blocks such that your code would look similar to the one below.

Run the code above and notice that

@BeforeMethod and @AfterMethod

@BeforeMethod	methods under this annotation will be executed prior to each method in each test case.
@AfterMethod	methods under this annotation will be executed after each method in each test case.

In Mercury Tours, suppose we like to verify the titles of the target pages of the two links below.

The flow of our test would be:

Go to the homepage and verify its title.
Click REGISTER and verify the title of its target page.
Go back to the homepage and verify if it still has the correct title.
Click SUPPORT and verify the title of its target page.
Go back to the homepage and verify if it still has the correct title.

The code below illustrates how @BeforeMethod and @AfterMethod are used to efficiently execute the scenario mentioned above.

After executing this test, your TestNG should report the following sequence.

Simply put, @BeforeMethod should contain methods that you need to run before each test case while @AfterMethod should contain methods that you need to run after each test case.

Summary of TestNG Annotations

@BeforeSuite: The annotated method will be run before all tests in this suite have run.

@AfterSuite: The annotated method will be run after all tests in this suite have run.

@BeforeTest: The annotated method will be run before any test method belonging to the classes inside the tag is run.

@AfterTest: The annotated method will be run after all the test methods belonging to the classes inside the tag have run.

@BeforeGroups: The list of groups that this configuration method will run before. This method is guaranteed to run shortly before the first test method that belongs to any of these groups is invoked.

@AfterGroups: The list of groups that this configuration method will run after. This method is guaranteed to run shortly after the last test method that belongs to any of these groups is invoked.

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked.

@AfterClass: The annotated method will be run after all the test methods in the current class have been run.

@BeforeMethod: The annotated method will be run before each test method.

@AfterMethod: The annotated method will be run after each test method.

@Test: The annotated method is a part of a test case

Conclusion

TestNG is a testing framework that is capable of making Selenium tests easier to understand and of generating reports that are easy to understand.
The main advantages of TestNG over JUnit are the following.
Annotations are easier to use and understand.
Test cases can be grouped more easily.
TestNG allows us to create parallel tests.
The Console window in Eclipse generates a text-based result while the TestNG window is more useful because it gives us a graphical output of the test result plus other meaningful details such as:
- Runtimes of each method.
- The chronological order by which methods were executed.
TestNG is capable of generating HTML-based reports.
Annotations can use parameters just like the usual Java methods.

Previous Tutorial Back to Selenium Tutorials Index Page Next Tutorial

Introduction to Selenium Grid

support — 2013-02-28T12:02:03+00:00

What is Selenium Grid?

Selenium Grid is a part of the Selenium Suite that specializes on running multiple tests across different browsers, operating systems, and machines in parallel.

Selenium Grid has 2 versions – the older Grid 1 and the newer Grid 2. We will only focus on Grid 2 because Grid 1 is gradually being deprecated by the Selenium Team.

Selenium Grid uses a hub-node concept where you only run the test on a single machine called a hub, but the execution will be done by different machines called nodes.

When to Use Selenium Grid?

You should use Selenium Grid when you want to do either one or both of following :

Run your tests against different browsers, operating systems, and machines all at the same time.This will ensure that the application you are testing is fully compatible with a wide range of browser-OS combinations.
Save time in execution of your test suites. If you set up Selenium Grid to run, say, 4 tests at a time, then you would be able to finish the whole suite around 4 times faster.

Grid 1.0 Vs Grid 2.0

Following are the main differences between Selenium Grid 1 and 2.

Grid 1	Grid 2
Selenium Grid 1 has its own remote control that is different from the Selenium RC server. They are two different programs.	Selenium Grid 2 is now bundled with the Selenium Server jar file
You need to install and configure Apache Ant first before you can use Grid 1.	You do not need to install Apache Ant in Grid 2.
Can only support Selenium RC commands/scripts.	Can support both Selenium RC and WebDriver scripts.
You can only automate one browser per remote control.	One remote control can automate up to 5 browsers.

What is a Hub and Node?

The Hub

The hub is the central point where you load your tests into.
There should only be one hub in a grid.
The hub is launched only on a single machine, say, a computer whose OS is Windows 7 and whose browser is IE.
The machine containing the hub is where the tests will be run, but you will see the browser being automated on the node.

The Nodes

Nodes are the Selenium instances that will execute the tests that you loaded on the hub.
There can be one or more nodes in a grid.
Nodes can be launched on multiple machines with different platforms and browsers.
The machines running the nodes need not be the same platform as that of the hub.

How to Install and Use Grid 2.0?

In this section, you will use 2 machines. The first machine will be the system that will run the hub, while the other machine will run a node. For simplicity, let us call the machine where the hub runs as “Machine A” while the machine where the node runs will be “Machine B”. It is also important to note their IP addresses. Let us say that Machine A has an IP address of 192.168.1.3 while Machine B has an IP of 192.168.1.4.

Step 1

Download the Selenium Server by here.

Step 2

You can place the Selenium Server .jar file anywhere in your HardDrive.But for the purpose of this tutorial, place it on the C drive of both Machine A and Machine B. After doing this, you are now done installing Selenium Grid. The following steps will launch the hub and the node.

Step 3

We are now going to launch a hub. Go to Machine A. Using the command prompt, navigate to the root of Machine A’s - C drive ,because that is the directory where we placed the Selenium Server.
On the command prompt, type java –jar selenium-server-standalone-2.30.0.jar –role hub
The hub should successfully be launched. Your command prompt should look similar to the image below

Step 4

Another way to verify whether the hub is running is by using a browser. Selenium Grid, by default, uses Machine A’s port 4444 for its web interface. Simply open up a browser and go to http://localhost:4444/grid/console

Also, you can check if Machine B can access the hub’s web interface by launching a browser there and going to http://iporhostnameofmachineA:4444/grid/console where “iporhostnameofmachineA” should be the IP address or the hostname of the machine where the hub is running. Since Machine A’s IP address is 192.168.1.3, then on the browser on Machine B you should type http://192.168.1.3:4444/grid/console

Step 5

Now that the hub is already set up, we are going to launch a node. Go to Machine B and launch a command prompt there.
Navigate to the root of Drive C and type the code below. We used the IP address 192.168.1.3 because that is where the hub is running. We also used port 5566 though you may choose any free port number you desire.

When you press Enter, your command prompt should be similar to the image below.

Step 6

Go to the Selenium Grid web interface and refresh the page. You should see something like this.

At this point, you have already configured a simple grid. You are now ready to run a test remotely on Machine B.

Designing Test Scripts That Can Run on the Grid

To design test scripts that will run on the grid, we need to use DesiredCapabilites and the RemoteWebDriver objects.

DesiredCapabilites is used to set the type of browser and OS that we will automate
RemoteWebDriver is used to set which node (or machine) that our test will run against.

To use the DesiredCapabilites object, you must first import this package

To use the RemoteWebDriver object, you must import these packages.

Using the DesiredCapabilites Object

Go to the Grid’s web interface and hover on an image of the browser that you want to automate. Take note of the platform and the browserName shown by the tooltip.

In this case, the platform is “XP” and the browserName is “firefox”.

We will use the platform and the browserName in our WebDriver as shown below (of course you need to import the necessary packages first).

Using the RemoteWebDriver Object

Import the necessary packages for RemoteWebDriver and then pass the DesiredCapabilities object that we created above as a parameter for the RemoteWebDriver object.

Running a Sample Test Case on the Grid

Below is a simple WebDriver TestNG code that you can create in Eclipse on Machine A. Once you run it, automation will be performed on Machine B.

The test should pass.

Summary

Selenium Grid is used to run multiple tests simultaneously in different browsers and platforms.
Grid uses the hub-node concept.
The hub is the central point wherein you load your tests.
Nodes are the Selenium instances that will execute the tests that you loaded on the hub.
To install Selenium Grid, you only need to download the Selenium Server jar file – the same file used in running Selenium RC tests.
There are 2 ways to verify if the hub is running: one was through the command prompt, and the other was through a browser
To run test scripts on the Grid, you should use the DesiredCapabilities and the RemoteWebDriver objects.
DesiredCapabilites is used to set the type of browser and OS that we will automate
RemoteWebDriver is used to set which node (or machine) that our test will run against.

Previous Tutorial Back to Selenium Tutorials Index Page