Future 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
Previous conferences
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
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.
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.
Key takeaways:
- Learning Selenium starting with the basics and covering a wide range of topics that testers need for doing their daily work
- Setting up the browsers you want to test, according to your operating system and requirements
- Using CSS selectors to identify the WebElements to use in your tests
- Page interactions: reading WebElement attributes, interacting with the page by clicking on items or typing in the fields
- Reading, deleting or setting cookie values
- Navigating through site pages
- Using WebDriverWaits to have reliable tests that wait for page events before doing anything else
- Plus other bonus features
