Archive for January, 2020

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?

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.

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.

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.

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.

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.

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.

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.