Talk

If you are doing UI automation, there is a high probability that you are using Selenium. Either directly, or in some framework, or by some tool that is built on Selenium. But did you ever wonder what is going on under the hood? How does it use the browser? How does it find elements? If that sounds interesting to you, this is a presentation for you.

What? Do you want more? Just curiosity is not enough for you? A good understanding of tools is helpful when dealing with edge cases. Paraphrasing Simon Stewart if you are surprised by stale element exception it means you either don’t understand the page you are testing or you don’t understand the tool you are using. I won’t help you know your page, but I can help you get a better understanding of the tool.

During the presentation, we will look into the performance of different locator types. How to do quick experiments in code. What is going under the hood? What can we find in the standard?

As developers and QAs, we’re concerned about to create add test coverage for our API’s through unit and integration tests using mocks to support a better strategy and removing dependencies.

Given the last wave of adopted architectural changes on many backend systems, the best coverage in any aspect is necessary. Even though developers create API Tests in low level there’re other testing techniques and levels to be applied in order to smash the bugs during the development process.

One of the main points of this presentation is to show how can we execute them applied to a pipeline to deliver our APIs through a Continuous Delivery or Continuous Deployment strategy following the test pyramid to have a faster feedback about our application health.

I’ll show how to develop a pipeline for API Tests beyond the unit and integration tests: health check -> contract testing -> acceptance testing –> functional testing, and how to do this with Rest-Assured with concrete examples and DRY techniques.

In the end of this presentation the participants will have a practical and functional example that can be applied in their teams.

Its nothing else, but big hype around automated testing on all levels. And it makes perfect sense, but… there are myths we tend to follow. There are common concerns we face and not always pay enough attention to. So if you have you ever been questioning automation on your project and if you ever had doubts about success – come to the talk. And also come if you haven’t – maybe you will.

Let’s talk about what modern automated testing lacks today. Tools? Hardware? Infrastructure? Understanding of “What are they doing”? Understanding of “Why are they doing it”? Ability to communicate with developers? Perseverance? Ability to work in a team? Mind? Keep trying to find the truth!

Very often the projects that have already gained the course and have a large codebase conclude that you need to write autotests. Including the UI autotests. In this situation, you don’t have the opportunity to remake the architecture for tests. As a result, tests became unstable and distract the product development team more than they help it.

In his talk Andrey will tell:

• how to lower the threshold to project participants tests;
• how to build simple and clear UI autotests architecture;
• how to make tests stable without changing application architecture and how to deal with emerging flaky tests;
• how to implement the solution in CI and build a reporting system that everyone will understand.

All solutions will be shown on the example of a specific demo application. This application you can see on GitHub. People can use ready-made solutions in their work.

The purpose of the talk: to show people how certain problems in UI testing automation of Android application are solved (case by case). These solutions don’t require reworking the application architecture or any significant revision for autotests.

This presentation is perfect for those who are often tormented by the obscure doubts about the effectiveness of what they do. For perfectionists and innovators. For those who care about which direction to move forward and how to develop. For those, who sometimes suffer from impostor syndrome. Who are occasionally infuriated by their own impotence and by the indifference of others when it comes to solving everyday tasks. For people facing burn-out and the ones who doubt whether they’ve chosen the right path.

You will learn about:
– How a QA engineer transforms into SDET / Dev / Metahuman
– What are the possible development vectors of hard & soft skills at various transformation stages
– Why all the hype around SDETs and T-Shapers
– How to constantly hold yourself to a high standard

Selenide is a popular library for writing UI tests for Web. But it also can be used for automating mobile apps on both Android and iOS. Even more, it allows re-using the same code between Web, Android, and iOS. Sounds like a tempting idea?

Write once – test everywhere. 🙂

There are thousand ways if not more how you can setup your automation testing environment. It is often crucial when it comes to stability and maintainability. While you can build a custom framework that fits your needs there are often already sophisticated setups or frameworks available that get you up and running very quickly.

WebdriverIO is one of these frameworks that is written in Node.js. It gets you up and running within minutes and allows you to scale up your test suite while maintaining your execution time by running tests in parallel. With its huge project community it is an ideal choice for small as well as big projects that use modern frameworks such as React, Angular or Vue.js.

In this talk you will learn everything you need to know to run a successful, stable and maintainable WebdriverIO framework. Christian will tell you everything from the basic concepts up to complex testing strategies you can do with WebdriverIO like frontend performance testing as well as complex browser interaction with Puppeteer.

Preparing Test Strategies for web-apps is better to define mechanisms that performance is according to business expectations even when business owners use non-numeric criteria of measurements (fast, super-fast, ultra-fast, lightning). Keeping in mind web-app tiers and utilizing OSS (ELK Stack) or Commercial (AppDynamics) tooling we were able to answer on most complicated questions appearing during performance tests. And of cause, the right chosen load generator tool could be natively integrated into the Test Automation ecosystem.

And a bonus story, when we did not exercise with monitoring/load tools. Some sunny days, verifying midnight Selenium Test automation results with Allure report and realizing that set of failed tests is not related to tested functionality, we start thinking about solutions get monitoring data and match with tests. In this talk, I want to demonstrate Webdriver browser Timing API capabilities introduced by W3C which you can use already tomorrow.

Shift Left is still a fantasy for most organizations, but what about Shift Right? It’s not just another buzzword–it’s short-hand for how to ensure your testing guides your release and post-release activities, and it feeds back into the planning cycle for your next sprint/cycle/project. Marcus will cover the current state of Shift Left, and pull the audience both earlier and later in the timeline, to a state where our software emits signals at every point. Using the most current information from leaders in the Observability space, a new picture will emerge–one of transparency, continuity, and most important: confidence.

Unit tests are guardians for your production code, but “Quis custodiet ipsos custodes?” (“Who will guard the guards themselves?”) What to do if coverage metrics are great, but code is still buggy? It’s time to test the tests! Come discover mutation testing.

Selenium 4 is coming! What’s new? What’s stayed the same? Why should you upgrade? When will it ship? Just how shiny is it?

In this talk, you’ll learn how to upgrade a project from Selenium 3 to Selenium 4, how to take advantage of new features such as “relative locators”, and how the new Grid implementation scales and can be observed.

Modern methods for coverage measuring are good only for development. However, the amount of useful information from coverage reports is extremely small. One the one hand all code lines weren’t involved during tests. On the other hand, the only important information is the percentage of coverage. And we are not interested in the absolute value, but we want a delta with the previous one. Artem will present some simple solutions that allow you to evaluate the coverage of tests written by test automation.

In automatic tests, it is often difficult to work with pages that differ depending on the screen size, type of user, localization, or other conditions. And when you work with such pages – a strong desire arises – “the page is almost the same, I just need one additional click for mobile version …”, and often “if / else” becomes the solution. In this talk, I want to show the approach that I use in the current project, which allows me to support and develop tests for 12 versions of the same web application. I called this Versioned Page Objects. It allows reuse of common logic between different versions of page through inheritance, and also overrides or removes some logic where necessary, without any if / else blocks across the code. TypeScript Code Examples.

Puppeteer by Google Chrome takes the world of browser automation. But can we use it for testing?

Sure! What features contain Puppeteer, why it’s better than WebDriver, and how it drives your tests faster? Let’s take a look of features of Puppeteer, as well of common testing patterns in it.

We will look also work on problems happening during Puppeteer testing and simple tricks to resolve them.

Even you already work with Puppeteer, this talk will be valuable to you!

AspectJ is a de facto standard implementation of Aspect-Oriented Programming (AOP) in Java. In this talk we are going to meet this tool, see how it works under the hood and what kind of problems it might help you to solve in Test Automation. For example, the most beneficial application of it is the possibility to log methods called during the test execution without adding logging commands explicitly. We will see how AspectJ is used in other tools and frameworks like Allure and Spring, and what is the price of the magic. Of course, there will be a demo.

API testing is one of the most important layers of software quality assurance. Nowadays more and more companies generally prefer REST technology to the Simple Object Access Protocol (SOAP) technology because REST leverages less bandwidth, making it more suitable for internet usage.

Testing and validation of REST services in Java is harder than in dynamic languages such as Ruby and Groovy. Rest Assured brings a simplicity of using these languages in a Java domain. It is one of the most powerful libraries for testing RESTful API. REST Assured provides a domain-specific language (DSL) for writing powerful, maintainable tests for RESTful APIs.

The aim of this talk is to introduce a development of a quick and simple automation project for testing RESTful services and a quick organization of a contract testing with REST-Assured library and JSON-schema approach.

Automated tests can provide results faster than manual ones and it’s possible to execute them more frequently. That allows us to test earlier in the development process, decrease the overall time needed for tests and what is probably the most important it’s possible to release faster and more frequently.

But what if we have more and more tests and even automated execution of them takes too much time – 10 minutes… 30 minutes… maybe even hours? Should we consider the ability to execute full tests set just a few times a day as something normal? Is adding more compute resources the only option to reduce the execution time? Or maybe there are too many high-level tests and some of them should be replaced by low-level ones according to the tests pyramid? Is the test pyramid still valid in the cloud world?

During the presentation, you will see how cloud services like AWS Lambda may be used to run tests in a highly parallelized environment that can speed up execution time even hundreds of times.

This talk describes an approach that allows us to get higher test stability and execution speed simultaneously simplifying the process of the tests data creation. The approach is based on replacement of backend services by mocks. A live demo of backend service emulation and dynamical creation of the test data for mobile application by using Java and WireMock open source library will be shown.

We have spent many years testing our applications and systems manually and with test automation tools. During this time many bug root causes have been classified and could be detected automatically with special static analysis tools. Most of them could be applied at the early stages of development even before code is integrated into the main development branch. In this talk, I will go through available solutions and demonstrate what kinds of issues may be detected automatically reducing the time and effort of traditional testing.

Every test automation engineer probably faced with the problem of stability of the locators and with the needs of their frequent correction when updating the product. This routine work could be automated. There are some well-known solutions for self-healing test automation, like Mabl, testim.io, Applitools but they are not suitable for most kind of projects and has obvious disadvantages. There is a new idea how to make more universal solution that is compatible with any project. Im going to tell you about the proof-of-concept of this idea and how it differs from the existing solutions. At what stage of development we are now, what problems we faced and what is the ultimate goal.

Microservices is more than a buzzword: it’s an industry-wide tidal wave. Companies are spending millions to break up monoliths and spin up microservices, but they usually only involve QA at the very end. This talk centers around real-world experiences, posing questions you can ask your developers/product people, and offering solutions for you to help make your service more discoverable, more testable, and easier to release.

Despite a lot of information regarding machine learning, it’s still not clear how QA could participate in the process of its development. Using real handmade example of the mobile application for the recognition of handwritten letters, we are going to review all the steps that were taken for its development.

As the result, we will make some assumptions about how QAs could be integrated into this process.

We are going to talk about:

– Dataset
– Building the ML model
– API
– Mobile application
– Post-deployment support

The talk will be interesting for people who even don’t know about ML as we will start with some basic introduction.

JavaScript has the biggest ecosystem. Building any system on top of it expects a good understanding of all modern libraries and approaches. Before writing any automated test you should consider how it should be executed. And any taken decision will last for years with your tests. How to create a stable and efficient testing framework? What makes a perfect testing framework for you?

Let’s look into the following questions and see how they can be solved with current tools in JS:

– Choosing proper abstraction level.
– Choosing a running backend: WebDriver/Chrome DevTools Protocol/Electron.
– Dealing with asynchronity: Promise Chain, Global Promise, async/await.
– Choosing test runner: Webdriverio, Protractor, Puppeteer, Cucumber, CodeceptJS, TestCafe, Cypress.
– Build a testing framework you will love, the one testing framework you won’t need to rewrite next year.

Let’s talk about most known device farms: Bitbar, Kobiton, Saurcelabs, AWS device farm. I’ll observe the following topics:

– proc & cons;
– parallelism and how it is organized on device cloud platform;
– how CI/CD process can be organized with this device cloud platform;
– what reporting tools devices cloud platforms provide.

2018 was another year full of updates in mobile testing area. Appium finally released Espresso Driver, migrated to W3C protocol, added find by image functionally and even exposed integration for custom plugins for element search, that anybody can develop and use.

On the other side, Google released AndroidX Test, open-sourced set of cross platform APIs that should make native test framework attractive as never before. Apple gave a speed boost with Parallel Distributed Testing in Xcode 10 and several cloud providers launch XCUITest support on real devices. Does Appium have anything left to oppose native test frameworks? Do Espresso/XCUITest still have any weakness?

I would like to address these questions and compare current state of each framework, its functionality, revive weakness and points to consider while selecting any of them.

I’d like to share expertise of using Selenium and Jenkins clusters deployed in Kubernetes based on AWS. I will explain how Kubernetes helps to scale infrastructure and save budgets for cloud services.

There is a lot of tools for UI automation in JavaScript – Cypress, Protractor, WebdriverIO, SelenideJS…

When you decide to do ui automation, you need to choose most flexible, maintainable, powerfull tool which can provide you reliable test results.

So…which one? 🙂

In the test automation industry, the Page Object pattern has been used for more than 8 years. During this time, Java has been updated from JDK7 to JDK11. It’s time to update the Page Object pattern. Atlas – Next Generation of Page Object, which uses the interfaces instead of classes, Page Object tree structure, embedded waits and clear assertions. In talk, I will tell about the core functionality of the framework, the developer, which I am and show it extension points. I will also demonstrate how to use one PageObject for two platform: IOS & Android without boilerplate code.

Modern web application testing is a hard and ungrateful job. But may be this is just because we still don’t have great tool for testing, that could be our friend not enemy? In this talk I will present you Cypress.io – free test runner made without Selenium or WebDriver. With Cypress you could make your tests quick, simple and useful. Short summary:

– setup and your first test;
– architecture and main capabilities;
– async code testing, components and API requests;
– run on CI/CD server;
– end of Page Objects with App Actions usage.

Will tell about real cases that may arise if you would not test a layout of your application. We’ll take a look at popular tools for automated layout testing and dive deep into Galen Framework usage. Consider how to build an automatic design review process in a scrum team and what pros and cons such process has in real work.

I am gonna show how to write UI tests from scratch, from A to Z. It’s gonna be a live demo, no slides, just hardcode. I would like to cover all aspects writing UI tests, including: infrastructure set up, test data management, complex code coverage, testing strategy, role of UI tests in automation, etc.

Technologies: Java, Spring Boot, React, Selenide, Docker, Docker Compose, TestContainers, Jenkins.

In overall, it would be just another story. Everyone will be able to take the code away. If you need to get an example how to start writing UI tests this talk would be way useful.

Record and playback tools like Selenium IDE have a stigma attached to them in our industry — they’re not worth your time, they produce tests that are impossible to maintain, and they’re only for non-technical people.

But with the new Selenium IDE, that’s all just a bad rap.

In this talk Dave Haeffner will squash the stigma by showing you examples of how Selenium IDE can reliably augment and level-up your testing practice regardless of your team’s test automation maturity or your level of technical experience. He’ll also share how he went from a record-and-playback naysayer to a Selenium IDE maintainer.

Artem works as a team leader for several test automation teams, and he often has to deal with code refactoring in bulk. When developing a plug-in for IDEA he noticed an API which can do refactoring. This API’s strength is that we know everything about the code we work with: all kinds of the variables and classes usage, annotations signature, etc. Artem got an idea to make plug-in which will ease the project refactoring when switching from one version of the library to another.

In this session, Artem will tell how this API works and give several examples of migration (from Allure 1 to Allure 2, from jUnit4 to jUnit 5) and synchronization of the code and Jira tickets (test cases).

Browser tests are known to be the flakiest ones. This is partly because browser infrastructure is complicated to maintain. But the second reason is – main stream browser automation tools such as Selenium server are far from being efficient.

A year ago I have shown Selenoid – a truly efficient replacement of the standard Selenium server. This year I would like to demostrate how to organize a fault-tolerant and easily scalable Selenium cluster using virtual machines in the cloud. I will start by setting up several Selenoid nodes and configure them to send logs and recorded videos to S3-compatible storage. Then I will run multiple Ggr load balancer instances allowing to use all running Selenoid nodes and organize a single entry point to the cluster. Finally we’ll discuss how to work with VNC and video recording in such cluster.

In this talk, I’ll share my experience of using a new API framework – Karate. This is a great solution for REST API automation especially for test engineers who are not familiar with API automation and does not confidence with his/her programming skills. Also, we’ll talk about Karate’s list of features and how to integrate it with UI automation testing. In the summary, I’ll summarize all the pros and cons.

Presentation on approaches, tools, automation techniques for testing Android applications. Including demo how we do it at Flo Health. Will be useful for qa engineers who would like to start woking on Android apps testing, developers and managers who would like to introduce testing at their project.

In this talk I’m going to cover desktop application test automation ways with Selenium, what obstacles have we met and how they could be resolved. I will talk about tools for elements search in Windows and Mac, tips and tricks of work with elements, proper way of work with system dialog windows, checking element presense, Jenkins integration and much more…

Step by step functional programming (or some part of it) became a daily routine of almost every software developer. At the same time, there might be an opinion that “monads” and “pure functions” are just toys for bored matured engineers. And testers should not look there for sure – they should test software, it doesn’t matter how it’s written. In my talk, I want to show that functional programming has a clear impact on software quality. Lots of defects will not even appear in the code which is written functional way. If you are interested not only in testing and finding bugs but also in conditions how to prevent them from the beginning – come to listen to my speech. We’ll check examples written in Scala working on JVM but Java or C# knowledge is more than enough to understand the material.

This talk is for those who already does test automation in Java or Groovy and interested in new tools and techniques in test automation. Also for those, who would like to understand if it is worth to learn Kotlin and use it on real projects.

We will review the most useful features of Kotlin that will help you in practice to solve real tasks. Also some libraries and tools will be demonstrated to simplify tests coding.

Layout testing seemed always a complex task. Galen Framework offers a simple solution: test location of objects relatively to each other on page. Using a special syntax and comprehensive rules you can describe any layout you can imagine. In this talk we will be talking about designing, implementing and running test cases with Galen Framework.

FaaS services (like AWS Lambda) allows flexibly run your separate functions with super-fast scaling, and great independency. Tests by their nature are perfectly fits for running in isolation. Theoretical limit of concurrent tests is millions, but for WebDriver tests problem is with avalilable browsers. Fortunately new hope is here – Selenoid, allows to scale your browsers farm to huge sizes. In this talk i want to show experiments about running NodeJS tests (ProtractorJS + MochaJS) into AWS Lambda and Selenoid as browser supplier.

100000 tests executed under half an hour – sounds like a myth? Well, we made it, and I’m going to tell you a story how we got there. Through surveys, we discovered that many companies desire to utilize the benefits from parallel tests execution to optimize their software development process. However, they struggle with the process. Lack of available tooling, documentation, tests data arrangement/deletion, handling E2E tests specifics like browsers, emulators, etc. We were one of this companies. Because of that, we created an open-source tool for the job. Throughout the presentation, you will find statistics where, depending on the type of the tests, the tests execution can speed up from 4- 40 times which makes the run of the 100000 tests possible for 27 minutes.

It will be shown how to utilize the tool, its various features and where/when it is appropriate to use it. Also, you will find example solutions to most of the common challenges in executing tests in parallel. We believe that in the near future the parallel tests execution will be a necessity, much like unit tests or continuous integration now. This will be one of the pillars for the companies to improve their competitiveness and effectiveness.

A test that was green yesterday can suddenly become red – for no apparent reason. Nobody changed anything. Just the moon is not in that phase. Just the matrix has you.

I will show my collection of real examples of flaky tests from my experience. These are really tricky investigations, that lasted many days, weeks and even years!

We’ll figure out how to write tests so that they are stable and independent of the karma of the developer.

My talk will be interesting to both testers and developers – anyone who loves to solve unsolvable puzzles.

Almost any application or software system manages data. It is hard to imagine test automation that is not affected by this fact. There are many differenct approaches how to prepare system under test, providing predefined test data: use application UI, invoke API methods, run business logic directly, access DB from test scenarios, etc. In this talk we will review most of existing approaches, starting from the easiest and the most popular ones and finishing with really tricky ways to manage your test data for large distributed systems. There is no ideal solution for every case or silver bullet, but I hope your toolset will become wider after visiting this talk.

With Agile adoption many things have changed in quality assurance and tester role. Ourdays the whole team is responsible for product quality. But not so many people understand how such high level approaches work in practice, how developer interacts with tester, what stages each task passes on the way from requirements specification to customer acceptance, who is doing what at each stage.

I have met only few teams, where developer and tester work closely together on a daily basis. Some projects try to same money on developer’s time, others try to have independent testing team without influence from developers side. Developers also don’t understad how tester could help them in practice. But this pair is able to significantly improve product quality and avoid many common issues.

In this talk we will cover motivation behind pair work of develoeper and tester, concrete practices and approaches at different stages, and advantages that both sides could achieve from such work style.

In my talk I will tell about challenges and questions which emerge in testing and test automation at microservices world. I will guide the listeners with practical examples of implementing integration and component tests using Spring Boot framework and TestContainers library. The talk will be interesting for beginners as a starting point to include microservices testing into the overall testing strategy.

Playtika started from a single monolithic application several years ago occasionally covered with unit tests. But now we have sophisticated architecture with hundred of microservices that handle several games, dozens of platforms and hundreds of features supporting millions of users. This all should work like a charm day and night. Which is definitely not possible without automated testing. So I will tell how Playtika has developed testing infrastructure with different layers of testing; what kind of tests we have and what for; when and where we run them; how we monitor them and which reports we build; what kinds of tools we use and why and more else. But the most important is which pitfalls we met on our way and the lessons we extracted from it.

This talk is about how to introduce effective gamification on a project. We will talk about different gamification modes and will take a look into real-life examples of successful gamification implementation for Test Team activities. We will review batch of artifacts and case-studies, including lessons learned and related highlights. Within main takeaways there will be re-usable instruments and piece of inspiration to start gamify your environment.

In this talk, I am going to show approach to which helps to integrate test automation into delivery pipeline. DevOps practices become more popular and test automation engineers should follow them. I will show the way how we implemented flexible browser cluster, dockerized services on-demand and infrastructure as a code. Utilizing capabilities of Ansible, Selenoid, Jira test rail