На данном выступлении мы познакомимся с последними тенденциями в мире автоматизации тестирования и узнаем о новом мистическом паттерне проектирования под названием Screenplay Pattern, который согласно легенде спасёт всех нас от излишних трудов и превратит весь ваш спагетти-код в конфетку:) Узнаем какие же принципы из всем известной и непонятной аббревиатуры SOLID нарушает всеми нами горячо любимый PageObject паттерн и ещё раз все вспомним о проблемах с которыми многие из нас сталкиваются. Посмотрим, как же мы сможем навариться на этих тайных знаниях и удивить своих коллег новыми словами.

1. 1CONFIDENTIAL
Screenplay Design
Pattern for QA
Automation
ROMAN SOROKA
December, 2016

2. 2CONFIDENTIAL
SCREENPLAY DESIGN PATTERN
FOR QA AUTOMATION
ROMAN SOROKA
December 15, 2016

3. 3CONFIDENTIAL
ROMAN SOROKA
• Lead test automation engineer in EPAM
• Activist of COMAQA.by community
• Over 7 years in IT.
• Relocated to Minsk from Moscow
• Roles in the career: developer, software engineer in
test, QA lead, delivery manager.

4. 4CONFIDENTIAL
Roman Soroka
rnsoroka@gmail.com

5. 5CONFIDENTIAL
The ground rules

6. 6CONFIDENTIAL
2
1
3
Agenda
SOLID
Principles
• Do you remember any development principles?
• What is the best size for the class?
• Which principles are violated by Page Object?
Best practices
• What is the right size for the class?
• How to write easy to maintain classes?
• How user stories and acceptance criteria can help?
Screenplay
Pattern
• What is an actor-centric model?
• How Screenplay pattern can help?
• Will you change your approaches to GUI test automation?

7. 7CONFIDENTIAL

8. 8CONFIDENTIAL
•Remember we are
developing
software!
We are developers

9. 9CONFIDENTIAL

10. 10CONFIDENTIAL

11. 11CONFIDENTIAL

12. 12CONFIDENTIAL

13. 13CONFIDENTIAL

14. 14CONFIDENTIAL

15. 15CONFIDENTIAL

16. 16CONFIDENTIAL
• There is a clean separation between test code and page specific code such as locators (or their use
if you’re using a UI Map) and layout.
• There is a single repository for the services or operations offered by the page rather than having
these services scattered throughout the tests.
• A page object is an object-oriented class that serves as an interface to a page of your AUT.
• The tests then use the methods of this page object class whenever they need to interact with the UI
of that page.
• The benefit is that if the UI changes for the page, the tests themselves don’t need to change, only
the code within the page object needs to change.
Page object pattern
Page Object advantages
Page Object ideas

17. 17CONFIDENTIAL
Examples of Page Object

18. 18CONFIDENTIAL
Page Element Action
SingleApplicationPage
Section1Base Section2Base FooterBase Actions1 UserData1
Section1Xyz Section2Xyz Footer1 Actions2
Section1Qwe Section2Qwe
Single page application
Data
UserData2
Actions3

19. 19CONFIDENTIAL

20. 20CONFIDENTIAL
Does size matter?
• "The first rule of classes is that they should
be small. The second rule of classes is that
they should be smaller than that.“
• Use your head as a benchmark.
What is the right size for java classes?

21. 21CONFIDENTIAL
Does size matter?
• We want our systems to be composed of
many small classes, not a few large ones.
Each small class encapsulates a single
responsibility, has a single reason to
change, and collaborates with a few
others to achieve the desired system
behaviors.

22. 22CONFIDENTIAL

23. 23CONFIDENTIAL
Composition over Inheritance

24. 24CONFIDENTIAL
User stories and acceptance criteria

25. 25CONFIDENTIAL
• The Screenplay Pattern (aka Journey) is an
approach to writing high quality automated
acceptance tests based on good software
engineering principles such as
• the Single Responsibility Principle
• the Open-Closed Principle
– It favors composition over inheritance.
– It employs thinking from Domain Driven
Design to reflect the domain of performing
acceptance tests.
– It encourages good testing habits and well-
designed test suites that are easy to read,
easy to maintain and easy to extend.
– It enables teams to write more robust and
more reliable automated tests more
effectively.
Screenplay Design Pattern

26. 26CONFIDENTIAL
Application under test and tools
• The application we will be testing is
the AngularJS implementation of the
well-known TodoMVC project.
• For simplicity, we will be using
Serenity BDD with Junit.
• Hamcrest matcher.
• And the long time promised
Screenplay pattern.

27. 27CONFIDENTIAL

28. 28CONFIDENTIAL

29. 29CONFIDENTIAL

30. 30CONFIDENTIAL

31. 31CONFIDENTIAL
The exemplary acceptance criterion
Now suppose we are implementing the “Add new todo items” feature. This feature could have an
acceptance criterion along the lines of “Add a new todo item”. If we were testing these scenarios
manually, it might look like this:
Add a new todo item
• Start with an empty todo list
• Add an item called ‘Buy some milk’
• The ‘Buy some milk’ item should appear in the todo list

32. 32CONFIDENTIAL
The example acceptance criterion
One of the big selling points of the Screenplay Pattern is that it lets you build up a readable API of
methods and objects to express your acceptance criteria in business terms. For example, using the
Screenplay Pattern, we could automate the scenario shown above very naturally like this:
@Test
public void should_be_able_to_add_a_todo_item() {
givenThat(james).wasAbleTo(Start.withAnEmptyTodoList());
when(james).attemptsTo(AddATodoItem.called("Buy some milk"));
then(james).should(seeThat(TheItems.displayed(), hasItem("Buy some milk")))
}

33. 33CONFIDENTIAL

34. 34CONFIDENTIAL
User Experience (UX) Design
In User Experience (UX) Design, we break down
the way a user interacts with an application
into goals (scenario titles), tasks (top-level of
abstraction in the scenario) and actions (the
lowest level of abstraction, below the tasks).
Layers of abstraction
• The goal describes the ‘why’ of the scenario
in terms of what the user is trying to
achieve in business terms.
• The tasks describe what the user will do as
high-level steps required to achieve this
goal.
• The actions say how a user interacts with
the system to perform a particular task,
such as by clicking on a button or entering a
value into a field.
The Screenplay Pattern encourages strong layers of
abstraction

35. 35CONFIDENTIAL
The Screenplay Pattern uses an actor-centric model

36. 36CONFIDENTIAL
• Actors need to be able to do things to perform
their assigned tasks. So we give our actors
“abilities”, a bit like the superpowers of a super-
hero, if somewhat more mundane. If this is a web
test, for example, we need James to be able to
browse the web using a browser.
– james.can(BrowseTheWeb.with(hisBrowser));
• To make it clear that this is a precondition for the
test (and could very well go in a JUnit @Before
method), we can use the syntactic sugar method
givenThat():
– givenThat(james).can(BrowseTheWeb.with(hi
sBrowser));
Actors have abilities

37. 37CONFIDENTIAL
• An actor needs to perform a number of tasks to
achieve a business goal. A fairly typical example of
a task is “adding a todo item”, which we could
write as follows:
– james.attemptsTo(AddATodoItem.called("Buy
some milk"))
• Or, if the task is a precondition, rather than the
main subject of the test, we could write something
like this:
– james.wasAbleTo(AddATodoItem.called("Buy
some milk"))
Actors perform tasks

38. 38CONFIDENTIAL
• The actor invokes the performAs() method on a
sequence of tasks
• Tasks are just objects that implement the Task
interface, and need to implement
the performAs(actor) method.
• You can think of any Task class as basically
a performAs() method alongside a supporting cast
of helper methods.
Actors perform tasks

39. 39CONFIDENTIAL
Serenity task class example
public class AddATodoItem implements Task {
private final String thingToDo;
protected AddATodoItem(String thingToDo) {
this.thingToDo = thingToDo;
}
public static AddATodoItem called(String thingToDo) {
return Instrumented.instanceOf(AddATodoItem.class). withProperties(thingToDo);
}
@Step("{0} adds a todo item called #thingToDo")
public <T extends Actor> void performAs(T actor) {
actor.attemptsTo( Enter.theValue(thingToDo) .into(NewTodoForm.NEW_TODO_FIELD)
.thenHit(RETURN) );
}
}
james.wasAbleTo(AddATodoItem.called("Buy some milk"));

40. 40CONFIDENTIAL
• To get the job done, a high-level business task will
usually need to call either lower level business
tasks or actions that interact more directly with
the application. In practice, this means that
the performAs() method of a task typically
executes other, lower level tasks or interacts with
the application in some other way. For example,
adding a todo item requires two UI actions:
– Enter the todo text in the text field
– Press Return
Task decomposition

41. 41CONFIDENTIAL
Tasks can be used as building blocks by other tasks
public class AddTodoItems implements Task {
private final List<String> todos;
protected AddTodoItems(List<String> items) {
this.todos = ImmutableList.copyOf(items);
}
@Step("{0} adds the todo items called #todos")
public <T extends Actor> void performAs(T actor) {
todos.forEach( todo -> actor.attemptsTo( AddATodoItem.called(todo) ) );
}
public static AddTodoItems called(String... items) {
return Instrumented.instanceOf(AddTodoItems.class). withProperties(asList(items));
}
}
givenThat(james).wasAbleTo(AddTodoItems.called("Walk the dog", "Put out the
garbage"));

42. 42CONFIDENTIAL
UI elements are targets
In the Serenity Screenplay implementation, we use a special Target class to identify elements using
(by default) either CSS or XPATH. The Target object associates a WebDriver selector with a human-
readable label that appears in the test reports to make the reports more readable. You define a
Target object as shown here:
Target WHAT_NEEDS_TO_BE_DONE = Target.the( "'What needs to be done?' field").locatedBy("#new-
todo") ;

43. 43CONFIDENTIAL
Page object data class
public class ToDoList {
public static Target WHAT_NEEDS_TO_BE_DONE = Target.the( "'What needs to be done?'
field").locatedBy("#new-todo");
public static Target ITEMS = Target.the( "List of todo items").locatedBy(".view label");
public static Target ITEMS_LEFT = Target.the( "Count of items left").locatedBy("#todo-count strong");
public static Target TOGGLE_ALL = Target.the( "Toggle all items link").locatedBy("#toggle-all");
public static Target CLEAR_COMPLETED = Target.the( "Clear completed link").locatedBy("#clear-
completed");
public static Target FILTER = Target.the( "filter").locatedBy("//*[@id='filters']//a[.='{0}']");
public static Target SELECTED_FILTER = Target.the( "selected filter").locatedBy("#filters li
.selected");
}

44. 44CONFIDENTIAL
A typical automated acceptance test has three parts:
1. Set up some test data and/or get the application into a known state
2. Perform some action
3. Compare the new application state with what is expected.
From a testing perspective, the third step is where the real value lies – this is where we check that the application does
what it is supposed to do.
Actors can ask questions about the state of the application

45. 45CONFIDENTIAL
Actors use their abilities to interact with the system
• The Todo application has a counter in
the bottom left hand corner indicating
the remaining number of items.
• We will use question object to check
the status of the displayed item.
• The test needs to check that the
number of remaining items is correct.
What is the right size for java classes?

46. 46CONFIDENTIAL
Test itself
@Test
public void should_see_the_number_of_todos_decrease_when_an_item_is_completed() {
givenThat(james).wasAbleTo(Start.withATodoListContaining( "Walk the dog", "Put out the
garbage"));
when(james).attemptsTo( CompleteItem.called("Walk the dog") );
then(james).should(seeThat(TheItems.leftCount(), is(1)));
}
The test needs to check that the number of remaining items (as indicated by the “items
left” counter) is 1.

47. 47CONFIDENTIAL
Auxiliary code
The static TheItems.leftCount() method is a simple factory method that returns a new
instance of the ItemsLeftCounter class:
public class TheItems {
public static Question<List<String>> displayed() {
return new DisplayedItems();
}
public static Question<Integer> leftToDoCount() {
return new ItemsLeftCounter();
}
}
This serves simply to make the code read in a fluent fashion.

48. 48CONFIDENTIAL
Question objects
then(james).should(seeThat(TheItems.displayed(), hasItem("Buy some milk")));
This code checks a value retrieved from the application (the items displayed on the screen) against an
expected value (described by a Hamcrest expression). However, rather than passing an actual value,
we pass a Question object. The role of a Question object is to answer a precise question about the
state of the application, from the point of view of the actor, and typically using the abilities of the
actor to do so.
Questions are rendered in human-readable form in the reports:

49. 49CONFIDENTIAL
The Question object
Question objects are similar to Task and Action objects. However, instead of
the performAs() used for Tasks and Actions, a Question class needs to implement
the answeredBy(actor) method, and return a result of a specified type.
public class ItemsLeftCounter implements Question<Integer> {
@Override public Integer answeredBy(Actor actor) {
return Text.of(TodoCounter.ITEM_COUNT) .viewedBy(actor) .asInteger();
}
}
The answeredBy() method uses the Text interaction class to retrieve the text of the
remaining item count and to convert it to an integer:
public static Target ITEMS_LEFT = Target.the("Count of items left"). locatedBy("#todo-
count strong");

50. 50CONFIDENTIAL
• Like many good software development practices,
the Screenplay Pattern takes some discipline to
start with. Some care is initially required to design
a readable, DSL-like API made up of well-organised
tasks, actions and questions.
Screenplay is finished

51. 51CONFIDENTIAL
Conclusion
The Screenplay Pattern is an approach to writing automated acceptance tests founded on good
software engineering principles that makes it easier to write clean, readable, scalable, and highly
maintainable test code. It is one possibile outcome of the merciless refactoring of the Page Object
pattern towards SOLID principles. The new support for the Screenplay Pattern in Serenity BDD opens a
number of exciting possibilities.
In particular:
• The declarative writing style encouraged by the Screenplay Pattern makes it much simpler to write
code that is easier to understand and maintain;
• Task, Action and Question classes tend to be more flexible, reusable and readable;
• Separating the abilities of an actor adds a great deal of flexibility. For example, it is very easy to
write a test with several actors using different browser instances.

52. 52CONFIDENTIAL
Grattitude
Antony Marcano
Founding Consultant
is best known in the
community for his
thinking on BDD, user
stories, testing and
writing fluent APIs & DSLs
in Ruby, Java and more
John Ferguson Smart
Mentor | Author | Speaker
is an experienced author,
speaker and trainer
specialising in Agile
Delivery Practices,
currently based in
London.
Andy Palmer
Mentor | Team management | Speaker
is co-creator of the
ground-breaking
PairWith.us screencasts,
regular speaker at
international conferences;
Andy has shortened the
delivery cycles of projects
across numerous
organisations with his
expertise in taking
complex technology
problems and simplifying
them to their essence.
Jan Molak
Extreme Programming and Continuous
Delivery Consultant
is a full-stack developer
and coach who spent last
12 years building and
shipping software ranging
from award-winning AAA
video games and MMO
RPGs through websites
and webapps to search
engines, complex event
processing and financial
systems.

53. 53CONFIDENTIAL
The Screenplay Pattern encourages strong layers of
abstraction
Designing Usable Apps: An agile approach to User Experience Design by Kevin Matz1
“A BIT OF UCD FOR BDD & ATDD: GOALS -> TASKS -> ACTIONS” – Antony Marcano,2
“A journey beyond the page object pattern” - Antony Marcano, Jan Molak, Kostas Mamalis3
JNarrate: The original reference implementation of the Screenplay Pattern4
The Command Pattern: “Design Patterns: Elements of Reusable Object-Oriented
Software”- Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides
5
TodoMVC: The Todo application tested in this article6

54. 54CONFIDENTIAL
THANK YOU FOR ATTENTION!