Robustness of Page Object Model in Selenium?

Question

I am using Selenium WebDriver with Java to develop automated regression tests for a web application. Currently, I am following the Page Object Model design pattern and using the PageFactory @FindBy annotation to declare all the web elements I interact with at the top of each page class and the TestNG @DataProvider annotation to pass data input to my test methods.

While this does not pose an issue at the moment, some of the pages I will need to work with have upwards of a hundred objects on the page (e.g. form for user info), and I am worried that my current methodology could run into performance and readability issues as the test suite grows. I am still new to both Selenium and Java, but have a few questions regarding this:

1. Are there any performance concerns with declaring hundreds of WebElements at the beginning of each page class, rather than say, storing each element's locator info in an Excel datasheet and iterating over that? Or, more generally, what are the main differences between using POM as opposed to creating a function library?

2. As is, my test methods are looking like:

   @Test(dataProvider="testData")
   public void test(String s1, String s2, ... )
   

Which can quickly become unreadable when passing in a lot of parameters. What alternatives are there for passing in multiple inputs to a test method?

Answer 1

My two cents on both of your questions:

1. Page Objects and locators

I don't see a reason why you would use an Excel for storing locator info. If you class becomes too 'long' (readability-wise), you could use a constants class as alternative - but that's only the locator strings, not the FindBy annotation, so it doesn't do much really. I've always kept all information about a single Page Object in one place (the class itself).

Note: don't forget that a single web app's page is not necessarily equal to a single Page Object! For example, a web page might have a navigation bar that's present in multiple screens: extract this into a separate Page Object. It's a basic technique to keep your classes as small as possible.

2. Passing in data to tests and Page Object methods.

What's working quite handy for us is XML. Basically, you feed a test with a single XML file that contains all data for that test.

Then you pass the different nodes to their respective Page Object methods. Your XML might look like this:

<xml>
  <login>
    <user>Test user</user>
    <password>qwerty</password>
  </login>
  <profile>
    <firstname>John</firstname>
    <lastname>Doe</lastname>
  </profile>
</xml>

Your test method might look like this (thinking in C# here).

public void ExampleTest(XElement xml)
{
    loginScreen.EnterData(xml.Element("login"));
    loginScreen.Continue();
    profileScreen.EnterData(xml.Element("profile"));
    profileScreen.Save();
}

Answer 2

1. You should not experience any performance problems. When you use POM approach in selenium the elements are actually initialized when you attempt to invoke some action on them. Unless you call some of the element method, they stay just declared but not take any space in memory. It is called lazy initialization. There is a number of posts about it over the Internet. For example this one.

2. This is the best approach to handle your test data. Not to make your code unreadable you can supply your fields with meaningful names. Like:

--

@Test(dataProvider="testData")
public void test(String meaninfulTestDataPiece1, String meaninfulTestDataPiece2, ... )

So to sum up: you're doing the things right.