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

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Using The Page Object Pattern

Semelhante a Using The Page Object Pattern (20)

Último

Último (20)

Using The Page Object Pattern