ScreenPlay Design Patterns for QA Automation

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

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

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.

4CONFIDENTIAL Roman Soroka rnsoroka@gmail.com

5CONFIDENTIAL The ground rules

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?

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

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

17CONFIDENTIAL Examples of Page Object

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

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?

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.

23CONFIDENTIAL Composition over Inheritance

24CONFIDENTIAL User stories and acceptance criteria

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

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.

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

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"))) }

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

35CONFIDENTIAL The Screenplay Pattern uses an actor-centric model

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

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

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

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"));

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

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"));

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") ;

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"); }

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

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?

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.

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.

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:

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");

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

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.

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.

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

54CONFIDENTIAL THANK YOU FOR ATTENTION!

ScreenPlay Design Patterns for QA Automation

In this document