Using The Page Object Pattern

Using the Page Object
Pattern to Improve
Functional Test Maintainability
Dante Briones
Principal Consultant
Electronic Ingenuity LLC
http://electronicingenuity.com

Friday, 07 August, 2009

The Page Object Pattern

• Technique for structuring test code that:
• Promotes reuse and reduces duplication
• Makes tests readable
• Makes tests more robust (less brittle)
• Improves maintainability, particularly if
the application is rapidly evolving



• Demos will be coded in Java
• Everything we discuss is applicable to other
strongly-typed languages (e.g. C#)
• Most things are applicable to dynamically-
typed languages (e.g. Ruby, Python, Perl)


Selenium IDE
Quick Poll

• How many using Se IDE?
• How many create tests primarily through
record & playback?


Selenium IDE
It’s Great Because:

• It’s Free
• It’s Free
• Requires little or no programming
experience


Selenium IDE
It falls short because:

• Selenese is not a programming language
• No support for loops/iteration
• No support for conditionals (if...else)
• No way to eliminate duplicated code!


Selenium IDE
Why is duplication bad?

• Has this ever happened to you?
• A tiny change to the app causes several
test failures?
• Let’s see an example


Demo


Selenium IDE
Why is duplication bad?

• Fixing the tests will require more work
than the change that caused the failure
• Duplication makes code less maintainable


Selenium IDE
Summary

• Great productivity for the ﬁrst few tests
• Maintainability decreases as the test suite
grows
• How can we do better?


Start Coding Your Tests
a.k.a.
“Write tests in a programming language”


Coding Your Tests
Quick Poll

• How many are using Selenium RC?


Coding Your Tests
How does this help?

• We can eliminate duplication by building
abstractions
• Let’s see an example of this


Coding Your Tests
What happens next?

• All commonly used methods get pulled into
the base class of all tests
• As the test suite grows, so does the base
class
• Uh oh...the base class starts getting too big


Coding Your Tests
How Big is Too Big?

• You can’t tell someone else has already
written the code you’re about to write
• Frequent version control conﬂicts
• Maintenance is an issue again


Coding Your Tests
How to rein in your base class?
• Observation: For any given page, most of
the behavior does not apply
• Example: you can’t change your password
on the “view cart” page
• What if we moved the page-speciﬁc
behavior into a corresponding class?
• Voila! The Page Object is born

The Page Object


The Page Object
What does it do?

• Consolidates the code for interacting with
any given UI element
• Allows you to model the UI in your tests


The Page Object
What does it do?
• Exposes methods that reﬂect the things a
user can see and do on that page, e.g.
• addItemToCart(), getPrice()
• getEntryTitle(), saveDraft(), publishEntry()
• Hides the details of telling the browser
how to do those things


The Page Object
Results

• Test code is very readable
• No duplication of Selenium API calls
• Interactive documentation via Ctrl-Space
• Eminently reusable code


The Page Object
Results

• This technique is framework-agnostic
• Has been used with Selenium, WebDriver
(Selenium 2.0), Watir, and others
• I’ve even used it to drive desktop apps


The Page Object
Results

• Because it encapsulates the details of the
test framework API:
• You can use this technique to simplify the
process of swapping frameworks
• In theory, you only need to reimplement
the Page base class.


But wait, there’s more!
It gets better!

• Page Objects improve maintainability
• They also provide an opportunity to make
test creation extremely quick (and maybe
even fun!)
• How? Page Objects + Method Chaining


Method Chaining
What’s method chaining?

• Change the signature of user behavior
methods so that they return the page
object itself
• Allows multiple behavior methods to be
called in sequence


Method Chaining
What will it do for me?

• Removes for “code clutter”
• Tests become even more readable


Method Chaining
How does it work in practice?
• All Page Object methods return a
reference to a Page Object
• If the “user action” moves the focus to a
different page, the method should return
that page object
• Otherwise, return the same page object
• Time for an example

Method Chaining
Results

• Test code is even more readable
• Very quick to write
• (Actually kinda fun. Don’t tell anyone!)


Method Chaining
Caveats

• Dependent on tool support
• Lots of options: IntelliJ IDEA, Eclipse,
NetBeans, VisualStudio


Method Chaining
Caveats
• Tool support depends on language
• Excellent support for strongly typed
languages like Java and C#
• Support is “up and coming” for
dynamically typed languages (Ruby,
Python, and Perl)


• Technique for organizing test code that:
• Promotes reuse and reduces duplication
• Makes tests readable
• Makes tests more robust (less brittle)
• Improves maintainability, particularly if
the application is rapidly evolving
• Is just as quick record & playback!

Q &A


Using The Page Object Pattern

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Using The Page Object Pattern

Similar to Using The Page Object Pattern (20)

Recently uploaded

Recently uploaded (20)

Using The Page Object Pattern