My Conference Talks

Future conferences

2019

ConTest NYC 2019
- Troubleshooting the fudge out of it; talk
- Designing you Java and Maven based Testing Framework; tutorial
Hustef 2019 – Troubleshooting the fudge out of it; talk

Others

CSS selectors webinar: https://www.youtube.com/watch?v=-xKvR2lxiVk

Previous conferences

2019

AutomationGuild online 2019 – Using IntelliJ to help you with your automation code; tool and code demo
UKStar London 2019
- Troubleshooting the fudge out of it; talk
- CSS selectors from zero to awesome; workshop
Nordic Testing Days 2019 – Selenium testing from scratch; tutorial
GOTO Amsterdam – Selenium tests the Object Oriented Way; live coding

2018

AutomationGuild online 2018 – Be productive in your automation with the Apache Commons helper libraries; talk
SauceCon San Francisco 2018 – The waiting game – how to design reliable Selenium tests; talk
Codecamp Cluj-Napoca 2018 – Be productive in your automation with the Apache Commons helper libraries; talk
DevExperience Iasi 2018 – The waiting game – how to design reliable Selenium tests; talk
CRAFT Budapest 2018 – Testers can write good code too; talk
Nordic Testing Days Tallinn 2018 – Designing your Java and Selenium tests. And your testing framework too (with Maven); tutorial
PalinQA meetup Budapest 2018 – Selenium tests the Object Oriented Way; live coding
HUSTEF Budapest 2018 – The waiting game – how to design reliable Selenium tests; talk
Devoxx Belgium 2018 – Selenium tests the Object Oriented Way; Tools in Action category, live coding

2017

Nordic Testing Days Tallinn 2017 –
- Selenium tests, the Object Oriented Way; workshop given twice
- lightning talk
STPCon Washington DC 2017 –
- Selenium tests, the Object Oriented Way; live coding
- Testers can write good code too; talk
TestCon Vilnius 2017 – Selenium tests, the Object Oriented Way; live coding
Codecamp Cluj-Napoca 2017 – Testers can write good code too; talk
HUSTEF Budapest 2017 – Testers can write good code too; talk

2016

Romania Testing Conference Cluj-Napoca 2016: A tester’s experience in learning automation; talk
SeConf UK 2016: Selenium tests, the Object Oriented Way; talk

If you are interested in me presenting one of these talks at your conference or meetup, please reach out by DMing me on Twitter @imalittletester.

My talks, workshops and tutorials

TALKS

Talk 25-60 minutes: The waiting game – how to design reliable Selenium tests

The biggest issue when it comes to Selenium tests is attempting to interact with the page elements when they are not ready. Trying to click an element before it is available, trying to select a value from a dropdown when it is not yet populated, checking an element attribute before it is available – these are some of the most common reasons for failures when it comes to Selenium tests.

Such issues can be avoided by using the WebDriverWait Java class to redesign the way you interact with your page. In this talk i will show you how to get from click to click and wait, from select a dropdown value to wait and select, and so on.

I will show you how to replace your standard Selenium commands, like click, with customised waits that you can write to adapt to your test environment conditions. I will show you how to rethink your page interactions from a waiting perspective. And, as an added bonus, how you can replace some of the assertions you write with corresponding wait methods.

Talk 25-60 minutes: Testers can write good code too

When you define yourself as an automation engineer, you are admitting to writing code. That comes with great responsibility: you should not just write code, you should write GOOD code.

You have handy tools and learning resources around to help you write tests that are easy to read, without much need for maintenance, clear and concise.

This talk will focus on how to make your code a star. I will go over some coding principles and best practices that will help you write clean code. The separation of concerns is just one of them. I will show the benefits of thinking like a developer, when it comes to the structuring of your test code. I will also show some of the tools, either from the IDE, or standalone, that highlight where your code can be improved, like: checkstyle, code review, automatic code inspections. Lots of tips, ideas, dos, donts and examples are included.

Talk 45 minutes, live coding, testers audience oriented: Selenium tests, the Object Oriented way

When you are writing Selenium tests to check for elements on your page, by taking the classic approach (checking for each element’s properties at a time), you might get to a large number of assert steps. This increases the lines of code your tests have, make the tests difficult to maintain and tricky to read.

Wouldn’t it be nice if the actual checking part of the test would be small, perhaps one line of code? With the approach I am going to present, you can do just that. Hence your tests will be small and clean. All you will need to do is model the pages/modules/items by using an Object Oriented approach.

Talk 45 minutes, live coding, developer audience oriented: Selenium tests, the Object Oriented way

Many times the task of a test automation person is to check that the content displayed on a web page is the expected one. That can mean either just the text, but also image attributes (like the source or the size), link attributes (like: label, URL it points to, whether it opens in a new tab), and so on. The classic approach testers use for such a task is to get these properties from the page with Selenium, then check them by using an assertion for each property. This leads to way too many assertions, and difficult to understand tests, without a clear meaning.

In this talk i will show a different approach for checking the contents of web pages, by modelling all the needed properties into Java objects. This way, comparison will be done between expected and actual objects, not each property one by one. This will lead to more meaningful and shorter tests, while also adding reusability and easy maintenance.

Talk/code demo 45-60 minutes: Be productive in your automation with the Apache Commons helper libraries

We all have to write some bits of code that seem too complicated or that take too much of our time. We wish there was a way to just have that code out of the box, and use it without much hassle.

Luckily, there is a collection out there, the Apache Commons project, that provides us helper classes and methods for all kinds of tasks, like:

working with Strings (extracting substrings, checking whether other strings occur in a given String, splitting them)
working with files and folders (creating, copying, moving or deleting them)
generating random Strings of specified lengths and containing specified or random characters
checking the OS the tests are running on
and so many more

Join my talk, as i will present some of the most useful helper classes included in the Apache Commons libraries,together with some of their frequent uses.

Talk 30-60 minutes: Troubleshooting the fudge out of it

An issue has been identified in the system. Its’ root cause is very difficult to determine. It is not very obvious how the issue occurs and how it can be reproduced. Somebody needs to spend time identifying the cause, fixing it, and making sure it does not re-occur. But how to do that? Many times people give up after trying a few things that did not yield a result.

The truth is, although it might be frustrating, this task is quite fun. Also, it can be done by testers, because we know a lot about how the systems work and interact with each other, and how our customers use them.

In my talk i will give some advice on how to get to the root cause of a seemingly impossible issue, starting from how to make sure you reproduce it, what are some common things you can check and what tools you have to help you.

Talk 25-60 minutes: X Lessons i learned from my developers

As an automation focused tester, i have always worked in a team where my developers were within reach. I could ask them questions or they would willingly offer some advice that would help me write efficient code, and become better at understanding how the software works. In this talk i would like to share the most important lessons i learned from working with them, to show how beneficial learning from developers is, and how working closely with them can help you easily solve issues by applying their way of thinking.

Talk 30-60 minutes: The story of the good automated test. From inception to production.

You know it. That little automated test that helps you evaluate the quality of your product. But how did the automated test get to be a good automated test? How was it created? How did the author decide on what the test steps should be? What software design considerations did the author use when writing it? How come it is so reliable and runs across so many environments?

In my talk, i will tell you the story of the good automated test. You will see how it evolved from an idea to a fully working and reliable test you can count on. I will go over the process of analysis, creation, setup of this test, so that you can also easily create your own little good automated test.

WORKSHOPS

Workshop 1.5 – 2 hours: CSS selectors. From zero to awesome

When writing Selenium tests, you need to identify the page elements by using some kind of selectors. XPATH, although much more complicated than CSS, seems to be preferred by many. Either because testers have tools that automatically extract them, or because they seem to clearly specify the path of the element.

In this workshop i will go over the benefits of using CSS instead of XPATH. I will show a ton of examples (with Java), from the easiest and simplest, to the most complex or even impossible. The purpose of the workshop is to get hands-on experience with identifying the CSS selectors for a wide range of cases, which will lead to you dropping XPATH altogether.

Woskhops 1.5 – 2 hours: Selenium tests, the Object Oriented way

TUTORIALS

Tutorial (full day): Designing your Java and Selenium tests. And your testing framework too (with Maven)

During this tutorial i will show you how to create and customize an automation project (framework) from scratch, using Maven.

Java based test design will be the main focus of the tutorial after the project was created: how to avoid repeating code, how to structure your test code, how/when/why to create utility classes and how to run tests.

I will show you how to write browser unaware Selenium tests and how to easily switch the browser on which they run. You will learn how to write tests that are environment unaware and how to make them run across your environments. Also you will get an idea of how to easily create tests for translation purposes, when your code runs across localized pages.

In addition, i will go over the most useful IntelliJ shortcuts, that will help you be more efficient when writing and structuring code.

All of these will be done against real code and real examples.

Key takeaways:

How to create a new code project with Maven
Understanding your pom.xml file
How to import dependencies with Maven
How to find what you need in the imported dependencies
How to create Maven profiles for running tests based on an xml file
Creating the browser instances and browser utilities
How to switch browsers in tests and how to write browser unaware tests
How to switch environments on which tests run and how to write environment unaware tests
How to create one test that can run across all the localized variations of a page
How to structure the project (where to place what), how to organize the project
IntelliJ shortcuts for common tasks, like: extracting methods from repeating code, extracting variables and field, auto-arrange of the code lines, etc

TUTORIAL (full day): Selenium testing from scratch

This tutorial is aimed at getting you started with Selenium testing and goes through all the concepts from scratch, to get you from ‘no Selenium knowledge’ to ‘now i can test my site’.

I will go over the following topics: setting up Selenium in your project, enabling browsers for testing on them, using CSS selectors to identify the WebElements you will use in your tests, and the actual page interactions. These include: reading page properties, interacting with the page, navigating through pages, working with Cookies, using waits for having reliable tests, just to name a few. The tutorial will focus on Selenium testing using Java and it will include testing on a real site, just as you would do in your day to day work.