Have something to share about Test Automation or WebDriver?
Become a speaker now


Computer Vision in UI testing

In a test automation job, we often meet with UI elements, that impossible find in HTML/XML sources – graphs, schemes, charts, maps, etc. That talk is about how Computer Vision can help us with testing those elements.

How does Selenium find Elements?

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?

Speed up your regression and reduce cost load with Selenoid + K8s + ReportPortal

We will talk about how our infrastructure for AutoTests was transformed on our project, in order to save money on infrastructure and accelerate the full run of AutoTests. About transformations from dedicated servers with complex pipelines to a flexible infrastructure based on K8s:

– K8s as a test launch environment and its connection with Jenkins.
– Modification of the Selenoid to work with K8s (open analog of Moon).
– Experience in using this infrastructure.

We will share our plans for further transformations of infrastructure for running tests and show the POC:

– The way to running tests on a scalable K8c cluster that runs on spot instances.
– The way to CI agnostic system.
– Information about ReportPortal (https://reportportal.io/ – an open-source tool for aggregation and analysis of tests) and show it in the context of the Demo.
– The way to running tests that are resistant to failures in the runtime environment.

API Testing following the Test Pyramid

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.

Test Gap Analysis and minimization of regression suites via Test-to-Code mapping with Drill4J

Test Gap Analysis is the process of identifying these gaps where new code has been deployed but hasn’t been tested yet. However, often your testing department does not know which parts of code have been changed by the developers. As a result, testers run some unnecessary tests while other crucial tests are overlooked.

With Test Gap Analysis we can find gaps in tests and help you avoid errors made due to recent, untested changes. In doing so, you can optimize the interface between developers and testers and avoid hotfixes after the system’s release.

With this talk Dmitriy will share and unveil new Open Sourced tool Drill4J, describe capabilities of Test-to-Code mapping and how you can minimize your regression time by identifying subset of tests, which should be run, which code have been changed and which changes are not tested after full testing cycle.

Confession of serial Automation QA

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.

Specifics and pitfalls of automation mobile hybrid applications with WebView

My talk is meant for QA Automation Engineers, QA Manual Engineers, and DevOps. I will describe the main issues which I had during setting up the mobile automation on one of the projects at EPAM and the ways how I solved them. I hope it will help my audience to kick off the mobile automation on their projects very fast.

BOF: What is missing from the modern automation engineer?

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!

Our CI/CD in Robots testing, on the edge of soft- and hardware

In this talk Alexei will show testing that goes beyond your daily work with the software. Insights into to Continuous Testing and CI/CD process in robots development, which stands on the edge of hardware and software testing.

You will learn about robot testing. Chosen strategy, what thorny path they have passed and what was the starting point.

Considered approaches to testing at different levels and for different parts of the system. What tools were used, how we came to them and what was the basis for their choice.

Solving the problems of Espresso Android autotests in the real world

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.

Flaky tests: The method.

Flaky, or unstable tests are an eternal headache for automation engineers.
In every build, in every test run some of the tests occasionally fail without a code change. It eats your time and soul. In my previous talks, I showed a lot of real-life examples with funny videos.

This time I will show new examples and focus on The Method – how to investigate and find the root cause of phantom test failures. We have A New Hope to overcome flaky tests.

Endless Metamorphoses of Consciousness or The Saga of a Transformer Man

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

BOF: Glorious past and promising future of Selenide

In this informal discussion group, we will discuss the future of Selenide: what should be in the roadmap, and what is not in focus. You can suggest your ideas and say a veto. 🙂

Influence the future of test automation!

Threesome: Selenide for Web, Android and iOS

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

Automated Performance Testing With WebDriver

Every frontend engineer is cautious about the speed of his web application, and many companies have SLAs that require their apps to be responsible after a certain time in order to not loose the attention of potential customers. Until this day, though, most web application are shipped without or just with a passive check of its performance.

Performance implications are difficult to understand and hard to predict. With Lighthouse, WebPageTest and other tools you are already able to capture tons of performance metrics of your application. However understanding and testing them often feels difficult and painful. By leveraging the browser DevTools capabilities you can enhance your functional test suite with testing methods that allow to make performance checks part of your test routine.

In this talk you will learn everything about performance and how to test it from end to end. Starting from what performance means for your users, how it can be captured using WebDriver, up to how you can build tests to automate your performance checks in CI/CD.

The Nuts and Bolts of WebdriverIO

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.

Test coverage myth busted: Test-to-code mapping and Test Impact Analytics

With this talk Sergey wants to re-think the nature of test coverage, based on project based experience.

Sergey will explain why it’s important to know the magic number 42, and why we misunderstand it. The talk will address capabilities of Test-to-Code mapping which is a cornerstone of Test Impact Analytics and source of data for Test Gap Analysis.

Sergey plans to unveil new tool, which can augment daily activities in testing, and highlight ideas that will help QA engineers to succeed in their testing efforts.

All levels of performance testing and monitoring in web-apps

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.

How to start UI automation in 15 mins with Puppeteer and why you will like it

This topic aims to manual QA engineers without experience in automation using JavaScript or to automation guys who have not tried anything except Selenium. You will find out how to start UI automation from scratch with Puppeteer: basic libraries, syntax. And a bit more — some features of Puppeteer which you will definitely like.

Closing the Loop – Shifting Right & Observability

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.

One, two, Terraform: Building automation infra is the goal!

Today it’s impossible to imagine companies that would not use CI / CD, one of the main components of which is testing. And if at the early stages of business test execution time is comparable to the other pipeline components, then with the project growth it increases significantly, both in terms of execution time and price. In our presentation, we will show you our experience in building an infrastructure for test automation using terraform. Scalability, easy support, simple deployment and configuration should be the main conditions for this infrastructure. Since you need to work not only with cloud providers but also with real computers (MCloud), Terraform has become the ideal solution in this case. As a result, we got an infrastructure that is practically independent of the technology for writing tests, is easily integrated into the process, and has an extremely low cost of running tests.

Silence of Code Coverage – Time to Test the Tests

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.

Testing swagger contracts without Contract based testing. True story.

Contract based testing is one of the main microservices testing solutions, but it has several restrictions: need deep knowledge about microservice, used frameworks and program language. In my talk, I will show how our team checking differences between Swagger/OpenAPI specs, generate json schemas from swagger json files and comparing json schema and real response.

Selenium 4

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.

Selenium in Kubernetes: lessons learned

10 years ago everybody was running Selenium Grid on hardware servers. 5 years ago we were living on virtual machines. 3 years ago it became a standard to use browsers in Docker containers. Nowadays a lot of teams are migrating to Kubernetes. During this session, I would like to explain why you should also start doing this and what are the technical challenges you should overcome to get a truly efficient Selenium installation.

Test coverage visualization

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.

WebdriverIO + Puppeteer. Double gun – double fun

In the automation world, W3C Webdriver HTTP protocol has been successfully used for a long time. With its help, many projects and libraries in various languages ​​have been implemented (selenide, protractor, webdriverio and thousands of others). But more and more teams decide to use Chrome Debug Protocol, in particular the Puppeteer tool. It is based on WebSockets, and has its own special features – two-way communication, ability to subscribe to events in the browser, and much more. In this talk, we will look at the capabilities of both protocols, experiment and combine them together in one project to make the browser work at full power, and take the best from both communication channels.

Versioned Page Objects: How to handle 12 versions of webapp

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.

Healenium – a little bit more than Selenium

Puppeteer is a new WebDriver? Secrets of flawless testing.

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!

The Valley of Success

Mountain climbing metaphors are old and tired. The Valley of Success is about crafting your automated testing framework in a way that maximizes maintainability by minimizing complexity. This talk will frame the way to create a test automation strategy keeping in mind the costs of creating, executing and maintaining tests. There are seven primary components of a successful automated test framework:

1. Assertions on Actions
2. Set up and Tear Down
3. Data Modeling
4. Configuration
5. Site Modeling
6. Wrappers and Helpers
7. APIs

This talk will cover each of these and provide specific suggestions for how to implement them while staying in the Valley of Success.

AspectJ in Test Automation

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.

Ups and downs of contract testing in real life

Contract tests between microservices seem like a simple idea. It can bring value to quality – if it is done right. There are a lot of basic examples out there – on the Internet. But what about the real case of contract tests implementation in the company? What challenges it will bring? What efforts it may cost to you and your team?

In my talk, I will share our experience of applying contract testing for a product with hundreds of microservices across multiple cross-functional teams. It will help you to be prepared now – for the future potential caveats in contract testing.

Best practices in API testing with REST-Assured

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.

Making SDETs from ppl with 0 programming experience

How deep technically could be an engineer to do best he can with automation? The biggest companies in the industry have different answers on this, and here in Preply, we implemented some solutions we saw think could work for us. In this presentation, I’ll tell you about the results we have, the learnings we got, and the problems we faced. This information would be useful for those who don’t stop on just automation and always will to be on the frontline of quality improvements. You will know of new possibilities and “new trends” on quality delivery. You will know how to cooperate with developers and help them to deliver even higher product quality even if you’re on vacation. 😉

Serverless – Automated Tests of web apps in the Cloud world

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.

Rethink Selenium best practices with JDI Light

I would like to talk about the best testing practices that come with Selenium, which should be known by every Test Automation engineer and how they can be improved with JDI Light framework. How well-known approaches like Page Objects can be extended with UI Objects, Data Driven Testing with Entities Driven Testing, etc. How BDD approach can be used Manual QA without automation engineers support. All new features of JDI Light framework from Best Practices viewpoint.

Stop worrying over unnecessary things if you are testing Mobile app

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.

Make BDD great again

I would like to share my story about how our team was building an efficient testing process, how these changes affect the development process overall, how to solve common problems of BDD-style tests with DEMO on real examples. My story begins with several failures/problems, which every team meets at the beginning of involving BDD tools in automation tests.

The next topic is including several improvements such as universal step definitions, cucumber expressions, own parameter types, text localization testing, involving REGEXP to test special symbols, etc.

After, slides cover solving irritable problems of BDD tests such as: getting, remembering and reusing unique data during test run sessions, working with API to avoid repeatable steps, file verifications in headless mode, excel files content, hash, screenshot testing, etc.

Static analysis tools as the best friend of QA

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.

Modern CI/CD in the microservices world with Kubernetes

In this talk, we will go through the design process of modern CI/CD for the microservices-based system with Kubernetes support. We will discuss how to verify consistency between microservices, apply different levels of quality gates and promote artifacts between environments. Thanks to Kubernetes we will review different approaches of environment resources optimization for development needs during CI/CD cycles.

Stability in Unstability. Self-healing test automation

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.

Infrastructure under test in Openshift

This talk will cover the usage of REST API in Kubernetes and Openshift for test automation.

Main points:

– Kubernetest base concept if it will be needed.
– Radanalytics.io.
– Benefits of Openshift.
– Automation of deployment in Openshift.
– Fabric8-kubernetes-client, XTF, radanalytics-utils as libraries for Java.
– Demo of Java code for deployment and management application under test, in the Openshift.

Break Up the Monolith: Testing Microservices

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.

Visual Testing Powered by CodeceptJS & Resemble.js

Imagine yourself to be QA of an application that monitors 1000’s of metrics and plots them, it would take a huge amount of time for a human eye to compare each metric plot and verify if it’s working as “expected”.

In the modern days of data Intensive analytical applications, it is important to not just test the usability of the application but also make sure that the data being plotted is not majorly away from the expected result patterns.

Resemble.js is a great tool for image comparison and analysis, which inspired us to write a helper for our existing UI testing library CodeceptJS, we are calling our helper codeceptjs-resemblehelper.

The session would focus on, How can QA’s take benefit of Visual testing with CodeceptJS and Resemble.js, We will look at use cases and work with the helper to see how visual testing works and how it could do wonders when it comes to saving time and bringing more quality confidence to the release cycle.

Quality assurance in project with Machine Learning

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

Selenium 4.0 and W3C: What You Need to Know

There is a lot of confusion about the WebDriver W3C standard: what does it mean, what do I need to do, and how urgent is it? Marcus will cover several steps you need to take in order to stay up-to-date with the latest version, as well as some of the history the project has gone through, which led to this historic standard. Code will be made simple, examples will be shown, and myths will be dispelled.

Design Decisions for Perfect JS Testing Framework

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.

Put your TestOps shoes on

Automate everything! That’s the most suitable description of DevOps culture. The culture that quickly created job position with the same name. Position, focused on broadly defined automation, leading to fast product delivery. And the division was pretty simple: DevOps = Process automation, QA = Test automation. But is it the right approach? What about (still more and more) popular “(Dev)TestOps” term? And finally, what if there is not enough time for complex test automation (common start-up case)?

I’ll show how to improve and speed up testing by process automation in 3 steps:

1. Automation supporting manual regression testing activities.
2. Automation maintaining project workflow, transitions, and statuses.
3. Automation enhancing bug catching and reporting during testing or normal application usage.

All of that in the context of 5 good (TestOps’) friends: Test Management Tool (Zephyr), Project Management Tool (Jira), Crash/Log Reporting System (Crashlytics), Communication/Notifications Channel (Slack) and Continuous Integration Tool (Jenkins).

Overview for device farms for mobile testing

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.

Test automation architecture. Advanced level.

The idea is to show more complex test automation architecture which goes beyond the ordinary arrange->act->assert or set-up->run tests->tear-down workflow. I’m going to show you working example, how can you test MapReduce jobs’ logic and REST APIs in a transparent, robust manner by using high-level logical abstractions in test automation framework via Jenkins pipeline. Will be shown with Kotlin + Gradle + JUnit + Jenkins pipeline as code.

Mobile automation state in 2019

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.

QA service mesh approach

As a Test Automation Architect have you ever solved the following problems (in the scope of testing a web application):

– impossible to work with file system on the server side (when SSH is unavailable or is the reason of tests flakiness);
– chaos in developing and maintaining of mocks/stubs for integration testing with 3rd-party systems;
– developers refuse to expose API that is needed only for testing.

I will describe the TAA approach of having a web application for testing needs that could resolve these and other problems. We will call this application QA Web Services and deploy it on the same server/container as the SUT.

We will consider benefits and drawbacks of the approach, go through useful tips. The target audience is Senior+ test automation engineers and Solution architects, basically it would be useful for anyone who wants to enhance the automation infrastructure, so that all team members would win.

Kubernetes – infinite space for your tests

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.

Building an advanced automation solution based on Appium

Will share my experience how to build an automation solution based on Appium that provides a possibility to run same mobile automation tests on both iOS and Android platforms. Also, going to show how to integrate mobile automation into a main development process, will include useful tips & tricks for mobile automation on real devices and practical demonstrations with code sharing.

Cypress vs Selenium Wrappers

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? 🙂

Wasteful waste or why everything is usually so slow in development

I think almost everybody experienced cases when things are moving very slowly in IT companies or teams. You have many people, talented engineers, Agile process and development speed is still below expectations. We try to focus on performance and efficiency last 10 years, improving our practices and tools. But we are still there in terms of speed when they are applied to real life cases. How is it possible? In this talk we will review the concept of waste circles and understand what are the main sources of time waste in development process. This concept would help you to check your processess, focus on right things and achieve much better results in your organization or team.

Let’s talk about Atlas

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.

Writing Business Facing Acceptance Tests with Canopy

Acceptance tests are crucial for success of any software project. Automation of acceptance testing significantly reduces the feedback loop, allowing to release faster and more frequently.

However there is one problem. Automated tests are written using programming languages and rarely can be easily read by non-technical stakeholders. There have been some attempts made to remove this gap, like Gherkin language, but it’s support might be very expensive and not pleasant for developers.

In this talk Serhiy will present Canopy – an F# DSL around WebDriver. It allows to describe acceptance scenarios in a form that could be easily understood by everyone. More than that, it also makes programming tests a joy, because it’s pure functional language and developers would get opportunity to try functional stuff on their work.

Cypress: testing without Selenium

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.

Voice assistants and chatbots automation

AI-powered chatbots and voice assistants are still emerging technologies, but they’re starting to gain traction in the workplace, as well as at home. Like any other software, such smart assistants have to be well-tested to ensure they meet people’s needs. But how can we test something so human-like?

In this talk, I’ll share my experience in voice assistant/chatbot development. Besides the general info about the technical stack, bot’s internals, challenges, and the existing test automation tools and frameworks, you’ll see several practical examples, based on Web, API and Voice interfaces.

Layout done – deploy! Layout testing with Galen Framework

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.

Ways of tests parallelization in JavaScript

People often think that running parallel tests in JavaScript is hard, and actually it is. We will explore possible ways of running JavaScript(nodejs) tests simultaneously using different approaches starting from basic and well-known splitting by files, and finishing with some crazy experimental things like worker threads, Functions as a Service, Isolates. Explanations and performance metrics are included!

How to write UI tests from A to Z

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.

Rollercoaster of Security Automation

Gonna talk about my experience of DevSecOps enablement on enterprise scale. Challenges the team have faced, solutions we found and some shortcuts that may help to avoid some mistakes we made. This will be a practical talk with code, hard data and live demos.

How I learned to stop worrying and love record and playback

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.

Distributed Automation using Kubernetes, Docker, Traefik and Helm

Cloud and the emergence of micro-services pose two challenges, besides cloud cost optimization, to the Selenium Grid based Distributed Automation solution for concurrent execution of UI automation.

First one is, in the world micro-services, teams wants to run their UI automated tests against the deployment of every Git branch (as part of validating a Pull Request before it is merged)
Speed will be an important factor in the pre-merge pipeline as described above. Using pure EC2 instance to scale Selenium Grid nodes is no longer feasible.Kubernetes/Docker based solution is the best so multiple hub/nodes sets can be created, used and destroyed using Helm.

The second challenge posed by the Cloud is, multiple accounts.Every company starts moving to Cloud with just one AWS account. But at a later stage, companies move into multiple accounts. With multiple accounts, accessing resources using private IP address becomes an issue.

This provides different problem like accessing hub using private IP address across different AWS accounts.

The solution to the second problem posed by Cloud is, Traefik with Kubernetes, Docker and Helm, which can help us reach the hubs within the Kubernetes cluster with a domain name for each hub like https://da-4eb769b.hub.test.expedia.com/grid/console.

Project needs refactoring? Here’s the IDEA!

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

Lean QA: automation, monitoring, experiments

The talk is about how development and QA process in a large company, which consists of ~20 smaller independent companies, can be established. How AB testing and experiments are used, how the production monitoring helps top prioritize effort in day-to-day work, how the automation matters and how QA can and should be treated as common responsibility of the team.

Bulletproof Selenium Cluster

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.

Multiplayer game testing in actions

Multiplayer games are complex systems that contains different sub-systems like: server that process all logic, platform that is responsible for users and their data, clients that may run in different platforms.Sounds like a general enterprise application, but with difference that all these things are combined into one single game where players can play with each others and everything is focused on users’ satisfaction. So priorities are different.

But organizing automated testing of a game is not a easy thing. Lack of technologies and information at stackoverflow are just the beginning of upcoming pain.

I will talk how we organized automated testing of such game, how our pyramid looks like, what challenges we met and what solutions we made.

Karate: powerful and simple framework for REST API automation

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.

Building a self-service marketplace for Test Data

With this talk i will sanctify Test Data Management process: sub-processes, goals, benefits, stages. Share approaches at different scale, and describe the case how to build TDM at small scale, utilizing open source stack.

Android Apps Testing in 2019

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.

Contract based testing for microservices and UI

The talk will be about building integration testing approach for microservices architecture, building contract based approach as a layer of integration testing between the services. Also I’ll share how it can also be applied to UI testing, when we separate UI from backend and then use just regular Selenium for UI verifications, as well as to client side performance testing. This will be a success story with real achievements and challenges described, lessons learned and where to start if you want to reorganize your testing pyramid into a perfect one and have tests pass rate almost 100%.

Automation testing desktop applications: Tips and Tricks

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…

TestCases as a Code

During my career as a test engineer I saw many different approaches to manage test cases. Many of them were written manually and stored in some test case managements system. In this talk I will share real experience of the team that tried to manage test cases as a code.

Monads for testers

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.

Dockerization of real mobile device farm and scalable QA automation ecosystem

Share our expertise in building up of highly scalable and effective infrastructure for Test Automation based on open-source solutions like Selenium and Appium by means of Docker.

We are going to show real case studies of our production challenges. Also we are going to talk about self-hosted mobile cloud solutions as part of QA ecosystem and how Docker simplifies our life in this area.

Kotlin with API tests

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.

How automation testing helps us to sell luxury bags

What is your first impression of a word Serenity? We also weren’t sure and thus checked the Urban dictionary. What we have found was the exact description of our test framework, which we have been using for 1 year already.

“Serenity is a loving, funny and caring person. When she’s in love, she loves hard. She will take you back even if you hurt me. She puts people over herself. Hardworking and smart. She doesn’t cry but when she does it’s streams create oceans. She is loud and will do her best to make you the best person possible. She sees beauty in everything but herself. But she’s amazing person to be in a relationship with. She’ll give you her mind, body and soul even when you don’t deserve it. Irreplaceable and hard to come by. Don’t give up on her because she won’t give up on you. She finds light in the darkest things. She’s the one you want to take home to your family. Athletic and always smiling. Serenity is not a common name and not a common person, so hold on to her.”
“Serenity is the whole package”
“Damn she looks good”

In my work, I would like to share with you our ups and downs, why we select Serenity and why sometimes we hate it but still love it. Why pure Selenium and BDD are cool and how Serenity can beats Selenide.

Live with me all the major periods of automation development in the Fashionette. Why is Serenity cool but not really?

Layout Testing with Galen Framework

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.

Allure 2: new gen test report tool

Everyone involved in the automated testing has to examine the autotest results. The bigger the project is, the more results one has to review. The world keeps getting faster, some products release several times a week if not a day.

Allure Framework is a popular instrument that makes analysis of autotest reports easier. This talk will cover its new version Allure 2. One of its main advantages is extendability: now you can adapt Allure to suite your needs using a plugin system. Besides that, it has a lot of interesting features ranging from test environment and test retries to text fixtures.

Scaling execution of ProtractorJS on AWS Lambda with Selenoid

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.

Deep dive into Selenium Waits

Implicit vs Explicit waits is a holy-war topic ever. But let’s dig deeper than just words. Let’s go thought the code and find out why there are so many different thoughts and how to deal with all of them in near perfect harmony.

Infinite improbability testing – execute all tests in parallel

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.

Xamarin.UITest. From Zero to Hero.

Xamarin.UITest is a C# test automation framework that enables testing mobile apps on Android and iOS. Mobile automation is not a piece of cake but Xamarin.UITest aims to provide a suitable abstraction on top of the platform tools to let you focus on what to test. This talk is not only an introduction of framework but also we are going to present its practical aspects, technical details, benefits and disadvantages. We will show a growing process from “Zero” – when you have only few local tests, to “Hero” – when you run your tests simultaneously and have fully integrated solution into CI/CD pipeline.

Flaky tests are a pain

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.

Arrange, mazafaka!

Every test should include 3 steps:

1. Arrange
2. Act
3. Assert

We can write tests that ACT: click buttons, fill forms, download files. Our tests can ASSERT: matchers, screenshots, even whole report portals.

But we forgot about the first step, we cannot ARRANGE. We use real databases. We send real SMS and Emails. We write hacks to close AD banners during test execution. It’s the reason why our tests become more and more complex, slow and flaky.

In this session we will learn again the basic step: how to prepare data and services for test execution.

Bro, manage test data like a pro!

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.

Bad testability is the root of most issues in test automation

Through my career I have seen so many times how test automation fails or just built to be very inefficient in the first place. After many years I came to the point that true root of most issues in test automation lies in application testability. Remember how easy tests are created and demonstrated during talks at any conference. It looks like you can easily automate 10-20 test scenarios per day. Multiply this number on team size and you can get number 50-100 automated test scenarios per day. Sounds amazing? But in reality this number could be 2-5 for “successful” teams and 1-2 for average team. In this talk we will review how effort is split during test automation activities, what parts hide most of complexity inside and eat our time. Hopefully at the end of the talk we will have some good recipies how to speed up test automation and significantly reduce time spent on it.

Developer + Tester = Quality++

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.

Test Automation Puzzlers

Integration testing for microservices with Spring Boot

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.

Can accessibility testing be automated?

I would like to share basics about accessibility, my experience in this type of testing and also to talk about accessibility from automation perspective: can this type of testing be automated at all, what tools can be used, can accessibility testing be fully performed without people evaluation at all?

Automated testing in Playtika: the story of evolution

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.

Don’t you like integration testing as me?

I will talk about integration testing nightmare (around 100 integrations with 3rd parties) and decisions that we did to get rid of integration testing. All talk is based on real project.

Powerful gamification

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.

How to get more from DevOps and Test Automation

Nowadays, many organizations are challenging agile, and focus more on DevOps as their brand new ALM methodology. Devops can be regarded as a next generation methodology beyond agile, especially with it’s special focus on test automation.

If you want your organization to survive in today’s agile world, you need to learn and adapt to the changing landscape of Devops and utilize test automation to help speed delivery and high quality. When it comes to a successful DevOps transformation, test automation is one of the keys.

For some reason, some people are afraid of getting their hands dirty with Devops and test automation since they do believe that they don’t have the know-how, the tools, “enough” time, and, most commonly, the staff and budget. Of course, some approaches can be very difficult, take a lot of time, and be very expensive. But they don’t have to be. Within my session, I will discuss some of the test automation approaches we (as Keytorc) have successfully implemented in Devops environments and while doing so I will try to keep all the blocking factors as low as possible.

Once correctly implemented, these solutions may bring many benefits into your Devops environment. Some of the most critical ones include: a powerful foundation to cope with the software testing challenges and a systematic approach to shorten the time-to-market delivery by supporting the quality of your products in preliminary stages.

My session mainly focuses on the challenges of Devops and Test Automation and it will guide attendees to practically utilize different aspects of test automation based on the experiences of Devops and Agile.

Test infrastructure on steroids

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