isElementPresent ?

Selenium RC we became quite used to using methods like iSElementPresent and waitForCondition/waitForPageToLoad to deal with Ajax and page loading events. With WebDriver we have to write them ourselves.


There are 4 important things going on here. In order:

1. Setting implicity_wait to 0 so that WebDriver does not implicitly wait.
2. Returning True when the element is found.
3. Catching the NoSuchElementException and returning False when we discover that the element is not present instead of stopping the test with an exception.
4. Setting implicitly_wait back to 10 after the action is complete so that WebDriver will implicitly wait in future.

Method

 isElementPresent(WebDriver driver,By by)  
 {  
    driver.manage().timeouts().implicitlyWait(0, TimeUnit.SECONDS);  
    try  
    {  
       driver.findElement(by);  
       return true;  
    }  
    catch(Exception e)  
    {  
       return false;  
    }  
    finally  
    {  
       driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);  
     }  
 }  

Regards,
Santosh.

How to write Xpath ?

In Selenium-Rc/WebDriver automation xpath is the one of the way to locate elements on webpage.XPath uses path expressions to select nodes/element in an XML/ HTML document.

How to verify in firebug?

• Open firebug in firefox/Chrome.
• Go to console.
• type : $x("<xpath>").
• Hit Enter.
• If it is correct path you can element in that console. If you mouse hover on that, the element will highlight in web page.

Example:

How to write Xpath?

Examples

Facebook signup form

1. Select first name

 //input[@id='firstname]     OR       //input[@name=firstname]   

In this case no need of xpath locator because we can use By.id, By.name,By.cssSelector.
By.id("firstname")    |   By.name("firstname")  | By.cssSelector("[id=firstname]")

2. Selecting first name input using First Name label

 //label[text()='First Name:']/parent::td/following-sibling::td/div/input  
                          or  
      //label[text()='First Name:']/../../td/div/input  

In above example,

parent	This keyword helps you to back track to parent node from child node.
following-sibling	This keyword helps you to go following-sibling.
preceding-sibling	This keyword helps you to go preceding-sibling.
..	This also helps you to go parent node from child node

See below table for more keywords

3. Using contains, starts-with

Select Last Name using contains	//label[contains(text(),'Last')]/../../td/div/input
Select Last Name using starts-with	//label[starts-with(text(),'Last')]/../../td/div/input

4. Index/position based

5. Some more expressions

If you have any doubts in xpath..Post your html code snippet here I would try to give you solution.

Sources  : http://msdn.microsoft.com/  |  http://www.w3schools.com/xpath

Happy Coding..! 

Regards,

Santosh

WebElements & Locators

In WebDriver automation everything related with web elements as it is web application automation tool.


WebElement is nothing but, all DOM objects appeared in the web page. To do operations with DOM objects/ web elements we need to locate those elements exactly.


WebElement element=driver.findElement(By.<Locator>);


As we've seen in the above statement we have to specify some locator to identify web element.
'By' is the class, in that class we have different static methods to identify elements. Those are,

1. By.className
2. By.cssSelector
3. By.id
4. By.linkText
5. By.name
6. By.partialLinkText
7. By.tagName
8. By.xpath 

---

1. By.className

See below example

Example:1

  <td class=name> </td>

WebElement td=driver.findElement(By.className("name"));

---

2.By.cssSelector

CSS selector is the one the best ways to locate some complex elements in the page.

See below some examples for easy understanding

Example:1

 <td class=name> </td>

driver.findElement(By.cssSelector("td.name"));     In css selector we can denote class name with dot (.)
                             (or)
driver.findElement(By.cssSelector("[class=name]"))    We can specify the attribute name and its value.


Example:2

<input id=create>

driver.findElement(By.cssSelector("#create")).sendKeys("test");    shortcut for denoting id is #
                                  ( or )
driver.findElement(By.cssSelector("[id=create]")).sendKeys("test")


Example:3

<td value=dynamicValue_13232><td>

driver.findElement(By.cssSelector("[value*=dynamicValue]"))     * is for checking contained value
(here value contains dynamicValue)


Example:4

          <div value=testing name=dynamic_2307></div>

driver.findElement(By.cssSelector("[value=testing][name*=dynamic]"));  


If you want to include more attribute values in locator criteria use css locator as above. 

---

3. By.id

See below example

Example:1

  <td id=newRecord> </td>

WebElement td=driver.findElement(By.id("newRecord"));


here we can specify the id attribute value directly.

---

4. By.linkText

See below example

Example:1

  <a onclick=gotonext()>Setup </a>

WebElement link=driver.findElement(By.linkText("Setup"));


This is the best locator for locating links (anchor tags) in your web page.

---

5. By.partialLinkText

See below example

Example:1

  <a onclick=gotonext()>very long link text </a>

WebElement link=driver.findElement(By.partialLinkText("very"));
                               (or)
WebElement link=driver.findElement(By.partialLinkText("long link"));


This is the locator for locating links (anchor tags) using partial text it contains .

---

6. By.name

See below example

Example:1

  <td name=WebDriver> </td>

WebElement td=driver.findElement(By.name("WebDriver"));

---

7. By.tagName

See below example

Example:1

  <td class=name> </td>

WebElement td=driver.findElement(By.tagName("td"));


If you want to get the entire text of web page use below logic.


driver.findElement(By.tagName("body")).getText();

---

8. By.xpath

              
In next post I ll post about xpath locators in detail.




Thank you.

QTP Vs. Selenium

It is good news for all Selenium testers...!

Challenges of Test Automation

1. Selection of Automation Tool – Today there are n number of automation tools available in the market and choosing a good automation tool is one of the major challenges that an organization often faces. This is majorly because there are several commercial tools which are expensive, there are open source tools which might not be reliable and there are tools of which an organization may not have sufficient expertise to make optimum use of.

2. No Defined Process for Executing Automation Project within an organization – Automation is like a project execution ,wherein you start with Requirement, then you design the framework as per your requirements and finally you roll it out for Test Case Execution. Lack of systematic approach and process will make successful automation really tough. As we have processes, guidelines and checklist defined for our development project; we should also have guidelines, processes and checklist available for Automation as well.

3. Availability of Right Resources – The right set of resources is a must when you are doing automation. This means the resources should be skilled enough to design and code robust scripting, so that it requires minimum time for debugging during maintenance.

4. Commitment from Customer or Management – Automation is time consuming and resource intensive task. Customer or management commitment is required if one wants to get the real benefit of automation. This paper will highlight the approach wherein you can maximize your benefits within reasonable period of time.

Overcoming the Automation Challenges Using Selenium

Selenium is an Open Source Tool developed by ThoughtWorks. There are a set of Selenium tools which when combined provides you the power to automate simple to complex web application. Some of the Selenium Tool under ThoughtWorks umbrella are:

Selenium IDE – It is a Firefox add-on that makes it easy to record and playback tests in Firefox 2+. You can even use it to generate code to run the tests with Selenium Remote Control.

Selenium Remote Control (RC) – It is a client/server system that allows you to control web browsers locally or on other computers, using almost any programming language and testing framework.

Selenium Grid – It takes Selenium Remote Control to another level by running tests on many servers at the same time and cutting down on the time it takes to test multiple browsers or operating systems.

Bromine – It is a web-based QA tool of Selenium that enables you to easily run Selenium RC tests and view the results. It scales beautifully, from the single tester who just wants to run some tests without all the hassle; to the corporate solution, with multiple user-groups and hundreds of test cases.

Selenium is the best open source tool for doing automation for web based application and it does not have any cost attached to it. The only cost is the effort which will go for designing and developing the script for the application.

There is no need to define or develop separate Life Cycle for doing automation in Selenium. If you have an existing automation process, Selenium Automation Life Cycle will fit into that well. If you are using Selenium as an automation tool, you will find a lot of information online for the best process or Life Cycle to be adopted for automation.

Selenium scripting can be done in a number of programming languages like C#, Perl, PHP, Ruby, Java etc, unlike other commercial tools which support single scripting language. Since Selenium scripting can be done in any language of choice, one can easily find right resources for the programming language chosen for Selenium Automation.

Last but not the least, since this tool comes at ZERO PRICE, an organization’s management will find that the only investment they have made is on the infrastructure and human effort and not on the heavy licensing cost.

JUnit Fundamentals

• JUnit was created as a framework for writing automated, self-verifying tests in Java, which in JUnit are called test cases.
• JUnit provides a natural grouping mechanism for related tests, which is called a test suite.

test case Vs TestCase class

• test case generally refers to single test, verifying a specfic path through code.
• To collect multiple test cases into a single class, itself a subclass of TestCase, with each test case implemented as a method on TestCase.
• test case class is called fixture.
• The TestCase class provides a default mechanism for identifying which methods are tests, but U can collect the tests urself in customized suites.

Points to Remember

• As long as you follow a few simple rules, JUnit will find ur tests and execute them:
• ur test methods must be instace level, take no parameteras, and return nothing. must declare them as a public void testMethodName().
• The name of ur test method must start with 'test' all lowercase.​

How To write simple JUnit

• Create a subclass of TestCase
• To create a test, write a method that expresses the test. Using a JUnit naming conventio that allows JUnit to find and execute ur test automatically.
• U place the method in a class that extends the JUnit framework class TestCase.
• To express how U expect the object to behave, you make assertions. (An assertion is simply a statement of ur expectation).
• TestCase class is the center of the JUnit framework. TestCase in the package junit.framework.

TestSuite

• A TestSuite is a Composite of Tests. It runs a collection of test cases.
• A TestSuite can extract the tests to be run automatically. To do so you pass the class of your TestCase class to the TestSuite constructor.

TestCase

• A test case defines the fixture to run multiple tests. To define a test case
• implement a subclass of TestCase
• define instance variables that store the state of the fixture
• initialize the fixture state by overriding setUp()
• clean-up after a test by overriding tearDown().
• Each test runs in its own fixture so there can be no side effects among test runs.​

Assertions

• The class TestCase extends a utility class named Assert in the JUnit framework.
• The Assert class provides the methods you will use to make assertions about the state of ur objects.

​methods of Assert class is

1. assertTrue(boolen condition)
2. assertEquals(Object expected,object actual)
3. assertEquals(int expected,int actual)
4. assertSame(Object expected,object actual)
5. assertNull(Object object).

Failure msgs

• When assertion fails, it is worth including a short msg that indicates the nature of the failure, even a reason for it.
• Each of the assertion methods accepts as an optional first parameter a String containing a msg to display when the assertion fails.
• also assertion methods has its own customized failure msgs.
• when an assertion fails, the assertion method throws an error: an assertionFailedError.

Failure Vs Error

• JUnit throws an error rather than an expection because in Java, errors are unchecked:
• When ur test contains a failed assertion, JUnit counts that as a failed test; but when ur test throws an expection(and does not catch it), JUnit counts that as an error.

Test has three basic parts

1. Create objects.
2. Invoke some objects.
3. Check the results.

Note

• In JUnit, the smallest unit of "test execution" is the test suite. JUnit doesn't actually execute individual tests,
• but only executes test suites, so in order to execute ur test, U neeed to collect them into a test suite.
• note that each test runs in its own instance of your test case class.
• This is one of the fundamental aspects of JUnit's design.

TestResult

• A TestResult collects the results of executing a test case. It is an instance of the Collecting Parameter pattern. 
• The test framework distinguishes between failures and errors. 
• A failure is anticipated and checked for with assertions.
• Errors are unanticipated problems like an ArrayIndexOutOfBoundsException.

TestFailure

• A TestFailure collects a failed test together with the caught exception.​

How to create testsuite?

• Create a method on ur test case class called suite(). IT must declared as public static Test suite(), taking no parameters and returning a Test object.
• In the body of suite method, crete a TestSuite object, and then add Test objects to suite:(either individual tests or other test suites).
• Return this TestSuite object.

==>manually building a test suite

TestSuite suite=new TestSuite();

suite.addTest(new MoneyTest("testEquals"));

suite.addTest(new MoneyTest("testSimpleAdd"));

==>Passing the TestCase class to TestSuite

return new TestSuite(MoneyTest.class);

•  JUnit searches testCase class for declared methods that follows the rules.