Future conferences

2020

  • European Testing Conference 2020: Processing test data read from a web page with Selenium; live coding
  • Nordic Testing Days 2020: Complex test scenarios with Selenium, Java and helper libraries; tutorial
  • TBA

Others

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
  • ConTest NYC 2019:
    • Troubleshooting the fudge out of it; talk
    • Top lessons i learned from my developers; lightning talk
    • Designing you Java and Maven based Testing Framework; tutorial
  • Hustef 2019 – Troubleshooting the fudge out of it; talk

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 emailing: imalittletester6@gmail.com.

My tutorials, workshops and talks

TUTORIALS

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
TUTORIAL (full day): Complex test scenarios with Selenium, Java and helper libraries 

Learning the Selenium framework for testing a website is just the beginning. Usually Selenium tests require more than just clicking on a button or reading data from a field. They involve generating the test data required and processing data read from the webpages. Writing the most efficient web tests, apart from Selenium, also require some Java concepts, for easily gathering data from the pages tests interact with. Generating test data to feed into the system through the website can also be done with either Java or some helping methods from Apache Commons.

In this tutorial I will show examples that anyone could encounter in their daily work, and provide a solution to creating the most efficient tests. This can be done using some Java concepts like: Objects, Enums, Lists or HashMaps. 

Three of the test scenarios i will tackle during this tutorial include:

  • Fill in a registration form (with Selenium) with randomly generated test data (by Java and Apache Commons). Discuss what types of data are required for different fields (int, String, dates), how to randomly select values from dropdowns, and how to generate data based on already selected values.
  • Read the information from a webpage (with Selenium), representing the data you submitted when filling in the registration form. Read them into corresponding data types. Check that this data is correct (using Java concepts). 
  • Interact with a video embedded in your page (with Selenium)
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

WORKSHOPS

Workshop 1.5 – 2 hours: Generating useful date and time values for your tests based on the current time

Working with dates and times in automated tests can be very difficult. You need to generate dates in different formats, or from different timezones. You need to generate yesterday’s date, or the date of the last day of the current month. How about the date of the previous Monday counting from the current date?

In case any of these are something you too need in your tests, this workshop will help you figure out how to generate these cumbersome date and time values. Staring: Java, LocalDate, LocalTime, LocalDateTime and SimpleDateFormat.

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.

TALKS

Talk 25-60 min: Processing test data read from a webpage with Selenium

First, you need to access a webpage. You then need to read some information from the webpage. And then you need that information in tests, in order to compare the actual information from the page to the expected one. 

Data read from the pages can be a real puzzle and a mess, if it is not properly organized. For example, what if you need to read the ingredients for a list of cakes? Or the price of coffee based beverages? How do you organize data read from ordered lists or tables, just to name a few? How do you extract the relevant information from the page and where do you store it? I will demonstrate the answer to all these questions on real examples with real code, using awesome Java concepts like Lists, HashMaps, Strings and useful helper methods. 

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/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.