You are here


Real-Life Test Maintenance - Anti-Patterns, Refactoring and Reviews

Note: There are prerequisites for attending this workshop. Please see the prerequisites section.

Automated tests are code too, and as such, we're obliged to not only make them functionally correct, we need to maintain them. In TDD we're told that refactoring the code is an important step in the process. Refactoring tests is also part of the job.

In this session, we'll go over anti-patterns in automated tests. We'll talk about code smells in tests - things that probably shouldn't keep the way they are. Smells like duplication, inaccurate naming, inaccurate asserts, leaky tests and more. But mostly, we'll refactor them to make them more readable, accurate and understandable for other humans. After all, they are going to stay with us for a long time. Finally, we'll look at how to do proper test review. How to use the time we have, when and how to do it, what to fix as we're reviewing, and let's not forget the human aspect - be nice to each other.

Since we're investing so much in automated tests, we need to make sure that our teammates, not to mention our future selves, can continue using tests with ease. If "Test maintenance" is bringing you down, it's time to get your hands dirty.

Key takeaways:

  • Identify anti-patterns and smells in tests
  • Refactoring patterns to make the tests succinct, readable and maintainable
  • How to do a test review



A computer with the following software installed:

  • IDE: Eclipse or Intellij IDEA
  • Java: 1.8

Workshop exercises can be found from here.

BDD Test Automation in Java with Cucumber and Serenity BDD

Note: There are prerequisites for attending this workshop. Please see the prerequisites section.

Testing has become a team sport, where collaboration is just as important as automation. It is essential to be able to write high quality test automation that is both easy to maintain, easy to understand, and that gives accurate feedback not only to testers, but to the rest of the team as well.

In this workshop, learn how to use Behaviour Driven Development principles to describe acceptance criteria as executable specifications, and then automate them with clean, readable test automation code using Serenity BDD and the Screenplay pattern. The Screenplay Pattern is an innovative approach to writing BDD-style automated acceptance tests that are easier to understand, easier to extend and easier to maintain.

You will learn first-hand how easy it is to understand and extend a test suite built using the Screenplay pattern. And you will see for yourself how Serenity BDD turns the Screenplay tests into clear, living documentation.

Key takeaways:

  • Learn how to turn acceptance criteria into executable specifications with Cucumber
  • Learn how to write high quality, reusable test automation code using Serenity BDD and the Screenplay Pattern
  • Learn how to turn automated tests into living documentation that helps not only testers but also developers, BAs and product owners



Attendees will have to bring their own laptops and will need a reasonable knowledge of Java coding.


A Crash Course in Low Pressure Test Coaching

Coaching, at its heart, is just a conversation. For most of us it doesn’t feel like “just a conversation” though… but what if it did?

In this workshop we’ll start with an everyday conversation between you and a colleague, slowly turning that into a fully-fledged coaching session. The step is actually a lot smaller than many seem to think giving us plenty of time to also look into helpful coaching tricks and techniques tailored specifically for testing. Finally I’ll show you how you can turn that formal “coach me” request to the low pressure conversation we’re looking for.

Coaching should happen everywhere, without people feeling nervous or pressured. This is my attempt to make that happen!

Key takeaways:

  • Realization: Test coaching doesn’t have to be mysterious, scary or complicated
  • Practical tools you can use in any conversation to turn it into a quick coaching session
  • Actual experience of coaching another tester

Tinkering with Arduinos and Python

Note: There are prerequisites for attending this workshop. Please see the prerequisites section.

Do you think Arduinos seem pretty nifty? Ever wondered what they are capable of if you throw some Python into the mix? This workshop is a fun hands-on tinkering session where you will learn how to combine python code with Arduinos! Control motors and power switches from your GUI buttons, or get your automated sensor readings on a dashboard. Or create an API. Code templates to expand and modify, as well as all necessary hardware will be provided (but at least 1 in 3 should bring a laptop).

Key takeaways:

  • Getting up and running with the whole chain from sensors&switches to GUI and API
  • Several examples of practical applications which you are likely to come across
  • Code templates to easily get started with several types of solutions



Attendee will have to bring a laptop

Revealing Architectural Testability

Sold out

A question I often ask testers is 'can you draw me the architecture of the systems that you test?' The answer is often stares blankly. I believe this is a core competency for an effective tester and the answer should be (more often than not) 'of course I can!' Architecture is a social construct, it is one of the main artifacts a team will gather around to discuss technical direction and customer need. If a tester cannot contribute effectively to this process, then an opportunity may be missed to gather important context for a balanced approach to testing.

Architecture is changing rapidly too. Testers will often be faced with cloud replacing the on premise physical architectures, or even hybrids of both, creating a further dimension of risk. Add containerisation and infrastructure as code then the big picture becomes even more complex. However, where there is challenge there is also opportunity for testers to add further value and play a greater role as teams adjust to change.

This tutorial encourages testers to interrogate, evaluate and elucidate the architectures they test, with the end goal of providing analysis of risk and insight into how testability can help address those risks. 

Key takeaways:

  • Attendees can recognise and explain the load balancing, web, API, database and shared access networks architectural layers
  • Attendees can recognise and explain the impact of cloud architectures on testing and testability concerns
  • Attendees will be able to sketch an architecture from a set of technical documentation and anecdotal sources
  • Attendees can identify key risk points within an architecture and build a context sensitive approach to testing
  • Attendees can apply models of testability to identified risks to propose enhancements
Subscribe to Epsilon