What categorizes as an asynchronous system?
Asynchronous systems do not depend on strict arrival times of signals or messages for reliable operation. Instead, in order to coordinate, they use event-driver architecture to achieve this. In today's world of micro-services, asynchronous operations have become more and more common. Some example platforms include Kafka, SNS, SQS, and so on.

Where are we currently as a community?
Event-driven and event-sourced systems are growing in adoption across the tech industry. In a digital world driven by micro-services and event-based data flows, these kinds of systems become increasingly important. But as developers and testers, how are we going to test something like this?

What are we used to currently?
Current testing solutions always are based on the assumption that any testing event is synchronous. Let us take for example, the Arrange-Act-Assert model that is commonly used across systems. They tend to assume that the workflow is synchronous and linear.

What do we need for the future?
Therefore there is a need for testers and developers, to think about the challenges involved in testing asynchronous systems and come up with creative ideas to solve these challenges. We need to also think about how you'd add test automation to the mix. Most importantly how are you going to generate a load that is as close to real-time and asynchronously? Is it even possible?

How is this talk going to help?
Well, I've had to cross this bridge recently and I’ll be sharing my experience. I’m not gonna say it’s perfect but it’s a good start. Maybe you can help me make it better?

Design a Test automation framework that maximizes output while essentially freezing the lines of automation code to maintain.

-- How to break down an application into functional areas
-- How to create reusable steps that work for any scenario
-- How to create an object-oriented framework

Learn to design test cases for solid automation.

We have tons of tutorials on how to use Selenium, Cypress, and Playwright but it is hard to find tutorials or talks which will help an exploratory tester design a test case that is more suitable for automation.

During my 15+ years of career, I often work with people who are early in their automation career but they lack the concept of how to design a good automation test case.

For example, how to use the before and after tests effectively to make sure a test is not fragile. In this talk, we will go through some real-life examples of how to adopt design thinking and what you need to know if you are taking your first step toward automation testing.

Attendees will learn about Cypress techniques and plugins that will allow them to incorporate security, performance, visual, and accessibility tests to their existing API and UI test suite.

We'll also talk a bit about how much testing is enough and how to organize tests.

Are you tired of chasing your development team for object IDs, and having to update your test automation scripts every time the structure of your app changes?

In this session, we’ll give you an overview of how you can take a visual approach to mobile test automation.

We’ll explore different options for automating the UI of mobile apps without having to rely on its internals (for example, through OCR or image recognition).

Plus, we’ll use real-life examples to demonstrate how you can use this approach to use a single script to automate your app across devices and platforms.

An introduction and examples on how to do test automation with Winium and AutoIt.

How to add Playwright(Python) tests into an established repository of tests in other frameworks.

We started with a set of Gherkin tests in Feature files, with step definitions which are written in Ruby and Selenium for automating the browser.

Then, we added in Karate, which also uses Feature files, into the mix. Now, I'm adding in Playwright(Python) using the Behave framework so that these tests can be written in Feature files, too, but with the step definitions written in Python.

All the tests are in Feature files and every scenario is tagged with the type of test (@ruby, @karate, @python), which lets us ensure that the right test runner is used for each test. Py4J lets the Python tests run Java code, including some custom Java code which we wrote for our Karate tests.

Takeaways:
- If all your tests are in .feature files, you can use multiple frameworks together and continue to run your old tests alongside your new ones.
- Py4J lets Python tests run Java code, so you can make use of all the Java libraries as well as the Python libraries
- Java can run Ruby, so I can enable my new Python tests to run old Ruby code, written for our legacy tests, by using Java
- A "dry run" of all the tests matching a set of tags will yield JSON logs which contain all the tags of all the tests you want to run, which lets you make a list of all those tests and then divide the list according to type and run each list of tests with the appropriate test runner.

APIs are one of the limelight topics in recent years, everywhere we can hear this term. Even though APIs (Application Programming Interfaces) have existed ever since software existed, in recent years it has become a critical requirement for being able to scale and grow your Product.

APIs allow pieces of code to bridge together as applications so they can work cohesively together.

API Testing has reached stardom nowadays. This process helps to ensure that performance, functionality, security, and reliability of software meet expectations - in other words, that the server (API) is able to serve several visitors simultaneously, return to the client, bring the exact response that was hit on the browser and so on.

If this testing wasn’t performed then consequently, ineffective APIs can result in integration difficulties, poor software quality, user frustration, and revenue losses.

POSTMAN is an API development environment used by more than 7 million developers today. With POSTMAN you can design, mock, debug, test, document, monitor and publish APIs all at the same time. Postman is very convenient when it comes to executing APIs. Postman is preferred due to its handy and simplified features.

Many would be familiar with POSTMAN testing essentials, but in recent times POSTMAN team has introduced a new codeless feature “Flows”, which is an API workflow builder.

These days Codeless testing is more popular where the tester never has to write a single line of code, in similar lines "Flows" will help you to automate your API requests without any coding. Flows is basically a codeless approach to chaining processes together. It really opens up Postman to a whole new audience.

So what will we uncover in this session?
- Glimpse of Low-Code / No-Code
- Know about Flows and its concepts
- Traditional API Test Automation approach
- Benefits of using Flows
- Interesting Use Cases in FLOWS

During the session you will learn about Report Portal - what kind of features it has and how they can help with automation analysis of failed tests. Some lessons which we have learned the hard way. And last but not least some statistics before / after Report Portal integration in our company.

How cool would it be if you can auto generate your test cases?

Have you ever wondered how to achieve maximum coverage for the applications you are testing?

All the answers are here!

I am going to tell you about one of the rarely discussed but very effective methods, Model-Based Testing and ways to build a mindset that helps explore that.

Key Takeaways:
- Introduction to Model Based Testing
- Ways to build a mindset for for MBT
- Build an actual model and auto-generate test cases from it
- Have some fun while doing it

How to combine open source tools to build powerful test automation capabilities.

Autonomous testing is the next great wave for test automation. What will it look like, and is there any way we can start doing it today?

In the next few years, we will see the rise of tools that not only execute tests on their own but also figure out what behaviors ought to be tested.

These tools will enable us to perform autonomous testing, not just automated testing.

Will these tools live up to their promise, or will they be gimmicky ploys that just waste our time?

And if they do deliver value, what will our development and testing workflows look like?

In this talk, Andrew Knight will answer these questions as he shares his vision for an autonomous future.

He will also demonstrate how you can actually start doing autonomous testing TODAY!

All it takes is a framework like Playwright, a visual tester like Applitools, and a little ingenuity.

By the end of this talk, you’ll be ready to ride the next great wave of test automation.

The era of hyper-automation is upon us.

A recent survey discovered organizations are shifting away from heavily manual approaches and into mainstream adoption and usage of test automation.

With the introduction of AI, testing capabilities are becoming more advanced, and they’ve become more accessible to a wider range of QA teams.

Join Frank Moyer as he discusses the upcoming trend of hyper-automation and how mobile testing teams can improve test functionality and increase productivity.

Leverage various AI techniques to test more like your users do.

I'll discuss various AI / Computer Vision techniques used to enable functional testing that is in alignment with the end-user experience. With over 2 years of adoption of these techniques in the web and mobile space, I'll share observations, techniques, and unique new defects we were able to catch.

52% of U.S. consumers said they would switch from a brand they like to another for better product quality.

Since many companies were forced to take a digital-first approach during the pandemic, digital customer experience has become paramount.

However, existing test automation approaches tend to take the focus away from the customer, requiring high investment in implementation and maintenance.

In this session, Fernando will make the case for why you should consider including low-code, E2E testing into your quality strategy, and share tips on which customer journeys to prioritize, how to integrate E2E tests into your pipeline, and what data to monitor to help you optimize quality for your users.

Imagine having an application under test where documentation is sparse, people with information can’t
be reached, or you’re otherwise left to ask yourself ‘but how does it actually work’?

In this Masterclass you will overcome all these worries and find solutions to explore your application, create targeted API tests and automate them. So at the end of this hands-on Masterclass every participant has made their own automated API-test.

To accomplish this we first start to explore a GUI that is connected to the API. Because we believe that
learning should always be fun, the GUI isn't just a boring webform, it's a digital escape room!

At the start of the workshop the participants will explore the GUI by trying to escape from the escape room. After that it’s time for the real work. Search for the API requests made by the application and automate them.

During this Masterclass we will support each participant on their own level. As a result the class is
suitable for testers with beginner or intermediate level experience with API testing and/or test-automation who wish to improve these skills.

Key Takeaways:
- Use DevTools to map the API
- Ways to map and process the information gained from the API
- Tactics, tips & tricks to focus on the most useful and important API calls first

How to train QA automation engineer from person without any IT experience in short period of time? Is it possible at all? What should be the priorities during the training and the focus? I will answer on these questions during my speech. I will use my own automation framework for the examples during the session: https://github.com/maroskutschy/Jasecu

What will I share with the attendees:

I will share concrete examples and details of the training.

Key Takeaways:
It is possible to train QA Automation engineer from ordinary people within IT knowledge in reasonable period.

Content of the presentation:
1. Programming language
2. Functional UI Testing Tool
3. Functional API Testing Tool
4. Visual and Layout UI testing Tool
5. Continuous Integration Tool
6. Tool for analysis of Automation Failures
7. Version Control System
8. Issue Tracking Tool
9. Test Cases Management Tool
10. Mindset and Habits
11. Meditation
12. Physical Exercise
13. Core (Soft) Skills

Are you looking for a comprehensive guide to mastering mobile test automation?

Whether you're a beginner or an expert, this talk will provide valuable insights and takeaways for optimizing your mobile testing strategy.

This talk will cover all aspects of mobile test automation, including its importance, benefits, and key concepts.

You will also learn tips and best practices for enhancing test coverage and how to approach automation testing for different mobile applications - whether Native or Hybrid.
 
Additionally, we will address common challenges organizations face during mobile test automation and look at potential solutions for overcoming them.

The golden rule of web performance states that for most web pages, less than 10–20% of the end user response time is spent getting the HTML document from the web server to the browser while 80-90% of the end user response time is spent on the frontend.

When we talk about performance testing, the most common activity that we do is to load test our backend servers. We come to a realisation that once we have optimised our servers and databases, that our application is now performant. However, this should not be the case.

Just because our servers have returned the response to a specific request doesn't mean that our users can see the response on the web page yet. There are many factors affecting frontend performance as well and it's as equally important to test to make sure that our users have the best user experience.

Historically, when we think of frontend and backend performance, we have to use separate tools. But what if there is one tool that can do this both?

In this talk, I want to introduce you to xk6-browser. xk6-browser is an extension to k6 which brings browser automation and end-to-end web testing to k6 while supporting core k6 features. It adds browser-level scripting APIs to interact with real browsers and collect frontend metrics as part of your k6 tests. With xk6-browser, this gives you the ability to measure how your frontend is behaving during certain events which would be difficult to catch from the protocol-level.

Here are a few takeaways for my talk:
- Learn why frontend performance is as important as backend performance
- Understand why performance testing is not just about load testing
- Know what xk6-browser is and why k6 has decided to introduce browser automation as part of the k6 ecosystem
- Know how to create a script using xk6-browser and combine it with existing features from k6

This talk will cover the basic concepts of Automation, Robotics Automation, intelligent automation, etc.

Audiences will be well equipped with the knowledge of the industry jargon for automation. And also be aware of how to kick-start their automation journey.

This talk will also be comparing automation technologies with one another and also be covering the common myths that exist alongside them.

The key takeaways will be :

1. Audience will be well equipped with Robotics and intelligent automation concepts and how to kick start their personal/professional journey in it.
2. Audience will be aware of the common use cases across various industries that leverage the automation and intelligent automation strategy.

Metaverse market is growing and there is lot of scope for testers.

In this session, you'll learn about:

-- Tools/ Techniques currently available
-- Market scope and how its going to scale up in next 5 years
-- Web 3.0

Creating great tests is only a start, the main job of the tests is to continuously give feedback during the SDLC process.

In this session, we will explore various ways to configure GitHub pipelines to orchestrate a pipeline including:

-- How to run E2E tests only after other tests are passing.
-- How to parallelize jobs for reducing execution time.
-- How to retry failed tests.
-- How to run a specific job at a specific time, say nightly.
-- Collecting test results and show them on the PR.
-- Create and collect code coverage metrics and display them on the PR.
-- Visibly show build and test states as badges on top of a PR.

As the world around us goes through digital transformation, the footprint of software grows enormously.

Increasing the footprint of software expands the attack surface, putting us all at risk of cyberattacks.

While some cyberattacks are a nuisance, others can be fatal, if not life-threatening.

More features mean more code, and more code means more problems.

Unfortunately, the practice of software minimalism has gone by the wayside to super-sized software systems loaded with a ton of features and functionality.

With security breaches being reported more frequently, software developers must step up their game to incorporate security into their code.

In this talk, I will discuss the importance of software security and engineering in providing cyber resiliency that can combat and withstand cyberattacks.

I will cover key best practices, lessons learned, pitfalls, and forward-leaning approaches to bring greater awareness to describe the importance of building better software systems that are intrinsically safer, more secure, and with better quality.

The main takeaways from this talk will be:

-- How do we reduce the attack surface by leaning on things we learned from the past?

-- What about our past can predict the future?

-- What about the future that can provide breakthroughs into securing our software world?

This session will provide information about desktop application automation with open-source tools such as Microsoft's WinAppDriver, Sikuli, and 'remote test execution' on various Virtual machines.

It will be helpful for whoever has a requirement to automate Windows native applications and perform the OS compatibility tests on different Windows OS.

This session will cover these topics:
- Open-source tools such as Microsoft's WinAppDriver and Sikuli for Windows application Automation
- Why Sikuli is used in a few instances instead of Microsoft's WinAppDriver
- Remote test execution on various Windows OS Virtual machines using Selenium/Appium grid
- How 'VMWare PowerCLI' is used to configure and interact with the Virtual machines.

The Metaverse blurs the boundaries between technology and the real world.

The new decentralized matrix of emerging Web 3.0 technologies from companies like Meta (Facebook) workspaces and Microsoft HoloLens 2.0 introduce fully immersive digital workforce collaborations within Virtual, Augmented, and Mixed Reality (VR &XR) worlds.

This leads to complex situations such as “how do you test next-generation technologies like NFTs containing digital artifacts that span across crypto wallets of testing merchandise rendered onto your 3D avatar representation of your digital twin self on your daily stand-up on Microsoft Teams Mesh.”

Basically, how to shape your testing in the Metaverse to test digital worlds.

In this session, you'll discover:
• Automated testing for XR & VR devices
• Image-Based Testing (IBT) for high-speed computer vision
• Real-world examples and lessons learned from automated testing.

80% of ERP transformations go over time or budget. While most transformational leaders recognize that utilizing DevOps can streamline these cumbersome projects, actually incorporating DevOps into ERP transformations has proven to be quite the challenge.

In this session, Pankaj Goel, CEO of Opkey, will explain how test automation is key for incorporating DevOps into ERP transformations, and will share how he used DevOps methods to successfully migrate 40 of The GAP’s business units from Oracle EBS to Oracle Cloud.

Are you using Playwright for functional testing and want to know how you can leverage them for performance testing?

In this session, Katarzyna (“Kat”) Kmiotek, a Quality Engineer at Zoopla, will share her experience integrating Playwright tests with Artillery.

You'll discover what Artillery is, how to integrate it with Playwright, and things to watch out for when creating performance tests.

In this session, you'll learn about:

-- What are the challenges in regulated markets (MedTech, Pharma, ...) in case of 3rd party software
-- What problems are regulated customers facing because of DevOps
-- Why Test Automation is a path forward for customers in these markets
-- How to address the typical challenges in regulated markets: 100% Traceability, Zero-Level-Of-Intrusion, mandatory audits

Most automation frameworks/suites remain unused by testing teams , and do not extract the desired ROI and acceptance across organisation. A real time solution to this problem is to build CI and/or CD pipelines around the automation suites for shift left approach and early feedback.

This will also help in bringing the automation suite closer to the developers team because of early feedback on every PR merge/code commit.

This talk shall talk about CI & CD methodology , how it comes under SDET responsibility ,and some tools (Demo) to implement the same.

Delivering high-quality software at a rapid pace is challenging and leveraging automation to manage this complexity has become an important skill for every team.

Yet all too often critical aspects of the delivery process can fall out of scope.

In this session, we will discuss some key strategies for defining and implementing a robust performance engineering practice as part of your software delivery pipeline to ensure the application provisioned in production is highly performant as well as high quality.

Do you find it hard to fit contract testing in your development workflow? What is the use of contract testing when we already have Swagger/OpenAPI specs?

Bi-directional contract testing can help with easily integrate (static) contract testing in your existing development/test workflow.

Traditional consumer-driven contract testing requires writing specific contract tests from scratch for the consumer.

On the provider side, it requires implementing test data and mocks to run the consumer contract tests against the provider. These tests often overlap with existing unit or integration tests for both consumer and provider, so why not reuse the existing tests instead?

Key takeaways:
-- You will learn what bi-directional contract testing (BDCT) is all about
-- You will learn how to perform BDCT with existing WireMock stubs using Pactflow
-- And how to do this without Pactflow (this is where swagger-mock/request-validators come in)

In this session, you will learn how to build a robust mobile testing strategy by the essential pillars below:

- Overview of iOS16 and Android 13
- Selecting the right testing tools
- Coverage and scale
- Real and virtual devices
- Security
- Visibility
- UX and performance testing
- Accessibility

By now, mobile app DevOps teams should be used to the annual release cadence of Apple and Google. But being used to these events and being prepared are two different things.

In the recent years, Agile has become a household name in the Development and Testing organization alike. While many teams adapted Agile practices like Daily Scrum, shorter Sprints and Retrospectives, they are still struggling due to manual build and deploy processes, slow and insufficient testing and integration issues. One needs to realize, that Agile cannot truly function without DevOps and DevOps without Agile.
This session will cover 10 steps that will help any company to get on the path of Continuous Integration and move closer towards the coveted Continuous Delivery. These will include setting up Repository for common artifacts, understanding and documenting the Build, Test, Deploy process flow, setting up of Continuous Integration, Automation, Monitoring and Reporting.
While adopting DevOps and following these steps does not guarantee smooth releases 10 times a day, it definitely puts the company on the right track towards faster releases with higher quality and happier employees.

Since ancient times we have heard the phrase "you do not ever test in production." That phrase, at a point, was reasonably accurate for all QA endeavors, especially for performance testing.

This taboo came partly from the misconception that performance testing meant loading and determining the system's limits by bringing it down with load tests.
But that was the past.

We are now in the modern age of CI/CD, service-oriented applications, the ever-expandable cloud, spread applications with microservices, and much more.

Performance testing is also evolving with these modern changes, just trying to push the system to its limits is challenging, weird, and at times pointless.

In this talk, Leandro will flip the establishment. He will explain why the traditional methods may not be so suitable anymore.

And in the talk, you will find several recommendations to embrace these types of tests in your precious production environments.

The recommendations will be as mind-blowing as load testing in production and even reaching the realms of manual load tests—staggering and eye-popping information delivered as usual with fun analogies and fantastic stories.