register

Agenda
When

  • 2023-03-28 09:00:00
    Invited
    Advanced Appium 2.0
    Workshop

    At this full-day (480 mins) workshop, you'll learn about advanced concepts in Appium. We will learn how to write a single script for Android, iOS, and mobile web apps. Once our tests are established, we will work on the framework design and report. We will also have a detailed look at how can we automate various mobile gestures using Actions API and mobile endpoints in Appium. The workshop will be based on the latest Appium's JavaClient.

    Advanced Appium 2.0

    At this full-day (480 mins) workshop, you'll learn about advanced concepts in Appium. We will learn how to write a single script for Android, iOS, and mobile web apps. Once our tests are established, we will work on the framework design and report. We will also have a detailed look at how can we automate various mobile gestures using Actions API and mobile endpoints in Appium. The workshop will be based on the latest Appium's JavaClient.

    Outline/Structure

    • Overview
      • Appium 2.0 Architecture
      • Locating elements using Inspector
      • Platform-wise Desired Capabilities
      • Start Appium Server programmatically
      • Understanding Appium server logs
      • Appium driver and plugin commands
      • Managing dependencies in Appium 2.0
    • Gestures
      • A deeper understanding of Gestures
      • Run through various gestures like Swipe, LongPress, Double-tap, Drag, and Drop using a w3c spec
      • Explore mobile: endpoints for the same gestures on both Android and iOS
      • Create our own complex gestures using the above endpoints
    • Practical Tips
      • Different ways to locater strategy for iOS and Android
      • Automation Hybrid application - Tips & Tricks
      • Video recording API
      • Simulate SMS only for Android
      • Run ADB shell commands via Appium
      • Seeding Photos on iOS-Simulator and Android
    • Appium Plugins
      • What is a Plugin?
      • How to build one using a plugin template?
    • Parallelize Tests
      • Understanding Appium Server Session
      • Desired Capabilities changes required to run tests in parallel
      • Using Appium Plugins to run tests in parallel on both android and iOS devices/simulators.

    Learning Outcome

    • Attendees will come away with knowledge of how to automate Android native apps with Appium.
    • Running tests single-threaded, in parallel, and distributed.
    • Also capturing critical report data (logs, screenshots, and video), and
    • Running mobile tests on a cloud test service.

    Target Audience

    QA, Automation Testers, Dev Engineers

    Links

    • It is mandatory to refresh your basic Appium skills as it is an intermediate to advanced Appium workshop

    Setup Links:

  • 2023-03-28 09:00:00
    Invited
    Selenium Deep Dive
    Workshop

    Selenium WebDriver v4 was released in Oct 2021. This version of Selenium WebDriver brings new features and capabilities for automation. At the same time, there are some features that are now deprecated and changed.

    If you answer yes to any of the following questions, this workshop is for you!

    • Are you using Selenium 3 and want to know how or why to update to Selenium 4?
    • Have you written Selenium tests before, but want to know about the advanced features?
    • Are you are struggling with flaky tests and want to learn strategies for fixing them?

    This practical, hands-on, course is designed to help automation engineers take their Selenium expertise to the next level. All attendees will leave with working Selenium WebDriver code on their machines and many techniques to successfully use the Selenium WebDriver API in their own context.

    Selenium Deep Dive

    Selenium WebDriver v4 was released in Oct 2021. This version of Selenium WebDriver brings new features and capabilities for automation. At the same time, there are some features that are now deprecated and changed.

    If you answer yes to any of the following questions, this workshop is for you!

    • Are you using Selenium 3 and want to know how or why to update to Selenium 4?
    • Have you written Selenium tests before, but want to know about the advanced features?
    • Are you are struggling with flaky tests and want to learn strategies for fixing them?

    This practical, hands-on, course is designed to help automation engineers take their Selenium expertise to the next level. All attendees will leave with working Selenium WebDriver code on their machines and many techniques to successfully use the Selenium WebDriver API in their own context.

    Outline/Structure

    In this session, we will go through the following topics:

    • Selenium WebDriver Architecture -> 15 min
    • New features since Selenium 3 -> 30 min
    • Hands-on exercises:
      • Selenium 4 Capabilities -> 30 min
      • Finding Elements -> 15 min
        • Locators (including with SelectorsHub extension)
        • Shadow Roots
      • Element State -> 15 min
        • Text
        • Attribute/Property
        • Rect
      • Element Interaction -> 60 min
        • Text Input
        • Dropdowns
        • Buttons / images / links
        • Action Inputs - keyboards, pointers, and scroll wheels.
      • Browser Contexts (Windows/Tabs/Frames) -> 15 min
      • Browser Interactions -> 15 min
        • Alerts/Prompts
        • Cookies
        • Executing JavaScript code 
      • WebDriverBuilder & Augmenter -> 15 min
      • Event Listeners -> 15 min
      • WebDriver BiDi -> 30 min
      • Waits -> 60 min
        • implicit
        • explicit
        • abstract
    • Test Strategy & Frameworks -> 90 min
      • What/How to Test
      • Maintenance Costs 
      •  Abstractions
        • Page Objects
        • Data Objects
      • Object Wrappers
        • Browsers
        • Elements
    • Whats next?

    Learning Outcome

    • Learn the new features and changes in Selenium 4
    • Know your migration path for Selenium 3 to Selenium 4
    • Implementation experience for various Selenium features, including the new Selenium 4 features
    • Navigating the Selenium landscape to find information on your own

    Target Audience

    Selenium users who want to get more out of their test code

    Prerequisites for Attendees

    • The workshop will be taught in Java as the programming language.
    • Below are the software prerequisites for the workshop:
      • IntelliJ Community
      • JDK 11+ (NOT JRE)
      • Git
      • Chrome & Firefox
  • 2023-03-28 09:00:00
    Invited
    Fix a Bug, Become a Committer
    Workshop

    Have you ever wondered how you can contribute to the Selenium project and become part of the team?

    Do you wonder how the different Selenium projects work under the covers?

    Selenium is a set of solutions that enables you to automate all major browsers with WebDriver, scale up and run tests in parallel through the Grid, record and play back user interactions with the IDE, and share all this knowledge though the Selenium website and documentation.

    However, only a handful of volunteers work to maintain this gigantic effort. If you would like to enhance your own Selenium experience while contributing back to the software that has defined so many of our careers, come to this workshop. In it we'll dissect the different elements of Selenium, dive into its internals, learn how it was built and how to make changes to it, and even fix or improve something that you can contribute on the same day! For the first time ever, we are offering this workshop at no charge to a limited number of qualified applicants - you only need to purchase a regular conference ticket to gain an extra workshop day! Learn more and submit your application here.

    Please note this is not a Selenium training workshop, but instead a walk-through of the project's codebase with guidelines on how to contribute.

    Fix a Bug, Become a Committer

    Have you ever wondered how you can contribute to the Selenium project and become part of the team?

    Do you wonder how the different Selenium projects work under the covers?

    Selenium is a set of solutions that enables you to automate all major browsers with WebDriver, scale up and run tests in parallel through the Grid, record and play back user interactions with the IDE, and share all this knowledge though the Selenium website and documentation.

    However, only a handful of volunteers work to maintain this gigantic effort. If you would like to enhance your own Selenium experience while contributing back to the software that has defined so many of our careers, come to this workshop. In it we'll dissect the different elements of Selenium, dive into its internals, learn how it was built and how to make changes to it, and even fix or improve something that you can contribute on the same day! For the first time ever, we are offering this workshop at no charge to a limited number of qualified applicants - you only need to purchase a regular conference ticket to gain an extra workshop day! Learn more and submit your application here.

    Please note this is not a Selenium training workshop, but instead a walk-through of the project's codebase with guidelines on how to contribute.

    Outline/Structure

    Join Diego Molina, one of the core maintainers of the Selenium Project, as we:

    • Explore the structure of the different Selenium projects
    • See how the source code is structured

    Discover how to navigate the codebase and maintain:

    • Selenium website and documentation
    • Selenium bindings in Java, Python, JavaScript, C# and Ruby
    • Selenium Grid
    • Docker Selenium images
    • Search out the bug database for an issue you can fix during the workshop
    • Fix a bug, add a test, or a feature and create a pull request to contribute it back
    • Get real time feedback and answers from the project core committers
    • Understand how releases get get done
    • Learn how to become a committer and be part of the team

    Learning Outcome

    Deep dive into the Selenium projects and when you leave, you will be able to start contributing to this massive open source project.

    Target Audience

    Anyone interested in understanding the internals of Selenium Project

    Prerequisites for Attendees

    A GitHub (https://github.com/) and a GitPod (https://www.gitpod.io/) account.
    Fork the Selenium projects to your GitHub account
    https://github.com/SeleniumHQ/selenium
    https://github.com/SeleniumHQ/seleniumhq.github.io
    https://github.com/SeleniumHQ/docker-selenium
    A stable internet connection

  • 2023-03-28 09:00:00
    Invited
    Driving Observability with Selenium Grid 4
    Workshop

    Selenium Grid can be a bit daunting to get up and running. Starting it is quite easy, but using it effectively can require pulling in third-party tools. In this workshop we’ll cover how to run your grid effectively, using best practices culled from several large grid installations.

    Driving Observability with Selenium Grid 4

    Selenium Grid can be a bit daunting to get up and running. Starting it is quite easy, but using it effectively can require pulling in third-party tools. In this workshop we’ll cover how to run your grid effectively, using best practices culled from several large grid installations.

    Outline/Structure

    • Describe what the grid is intended to solve, then get into how it solves it
    • Going deeper into the funnel, how does it get its instructions, and how does it pass them to the nodes?

    Set-up

    • We’ll start with the conventional setup of hub and node servers running on the same box, for simplicity.
    • Different options and flags that can be used when starting the hub/node processes
    • What kinds of logging do the nodes/hubs do that can help in debugging and investigating problems?
    • What is Docker?
    • How do you setup standalone & grid:hub-node using docker?
    • Using docker-compose to simplify docker grid setup process

    Running

    • How do you run a test in a container?
    • How do you run a test against the docker grid setup?
    • How do you look at the logs of tests running in a container?

    Advanced Grid:

    • How to build your own docker image with custom browser versions
    • Creating a hybrid Selenium Grid (docker + a local IE/Safari node).
    • Integrating Selenium Grid to the CI pipeline (Jenkins).
    • Setting up a UI manager for all your docker installations
    • How do you scale containers?
    • Running tests in parallel against a scaled Selenium Grid

    Extras:

    • Selenium Grid on Amazon ECS using ecs-selenium
    • Overview of third-party tools

    Learning Outcome

    • What Selenium Grid is and are its capabilities
    • How to run a grid
    • How to scale nodes
    • How to debug
    • How to build your own docker images for custom browser requirements

    Target Audience

    Anyone who wants to learn about Set up, debug and Scaling Selenium Grid

    Prerequisites for Attendees

    Selenium(mandatorily) - As we will focus only on Grid and won't cover how to write a script.

    Docker

    Windows: https://docs.docker.com/engine/installation/windows/

    This will include installing Hyper-V

    Mac: https://docs.docker.com/engine/installation/mac/

    - This will include installing the latest version of VirtualBox

    Linux Distributions: https://docker.github.io/engine/installation/linux/

    - The requirements will vary depending on the flavor of Linux being used

    Selenium-server-jar (latest): https://bit.ly/327RZjR

    Latest Selenium 4 version 4.3.0.jar

    You will also need the browser drivers and language bindings necessary for your target configuration, listed on this page: https://www.selenium.dev/downloads/

    Optional

    - If you intend to work with an auto-scaling Grid, an AWS account with full EC2 permissions.

    - It is also recommended that you have Eclipse or IntelliJ, a GitHub account, and an open USB port so participants can share files using a thumb drive.

    Tracing Selenium Grid
    1. Install Coursier via a homebrew `brew install coursier/formulas/coursier`
    2. Install Jaeger via docker
  • 2023-03-28 09:00:00
    Final_Accepted
    State Model-Based Testing Using Selenium
    Workshop

    State Model-Based Testing (SMBT) is an effective testing technique that allows you to visualize your application and to generate and automate test flows by using different models of the application under test, thus obtaining a large number of test scenarios.

    When certain paths of the application are changed, the benefit of using SMBT is that you will only have to modify the states and transitions that apply to that change.

    The purpose of using SMBT is to:

    • Discover another way to view the application under test
    • Test with a variety of randomly generated flows
    • Gather a big number of test runs so we can later investigate the parts of the model where tests have failed the most or the parts that have a higher fixing priority for the product under test.

    In this workshop, we will work in groups to model the behavior of a chosen web application and then write automated tests in Python, using SeleniumWebDriver and AltWalker, to execute the models we created and cover auto generated paths through the application.

    The State Model-Based workshop is a great opportunity for people who are already familiar with automation or coding. However, if you lack programming skills, this shouldn’t be an impediment as you will work in teams and get support from your peers.

    State Model-Based Testing Using Selenium

    State Model-Based Testing (SMBT) is an effective testing technique that allows you to visualize your application and to generate and automate test flows by using different models of the application under test, thus obtaining a large number of test scenarios.

    When certain paths of the application are changed, the benefit of using SMBT is that you will only have to modify the states and transitions that apply to that change.

    The purpose of using SMBT is to:

    • Discover another way to view the application under test
    • Test with a variety of randomly generated flows
    • Gather a big number of test runs so we can later investigate the parts of the model where tests have failed the most or the parts that have a higher fixing priority for the product under test.

    In this workshop, we will work in groups to model the behavior of a chosen web application and then write automated tests in Python, using SeleniumWebDriver and AltWalker, to execute the models we created and cover auto generated paths through the application.

    The State Model-Based workshop is a great opportunity for people who are already familiar with automation or coding. However, if you lack programming skills, this shouldn’t be an impediment as you will work in teams and get support from your peers.

    Outline/Structure

    Part 1 - Introduction to SBTM and the app under test - 2 hours (9am - 11am)

    The first part is dedicated to theoretical concepts and getting familiar with your setup during the workshop. You will:

    • Meet your instructors and peers
    • Learn the theoretical aspects of modeling an application and State Model Based Testing
    • Discover the tools you will use for modeling and the application under test

    Part 2 - Modeling - 2 hours (11am - 1pm) 

    Through hands-on group modeling, you’ll learn how to create the model of an application. You will:

    • Work in teams to model the behaviors of a simple web app
    • Control the test coverage through generators and stop conditions
    • Add business logic to the model through actions, guards and data
    • Combine different models to obtain more complex scenarios

    Part 3 - Implementation - 3 hours (2pm - 5pm)

    With the help of ensemble programming, using Python and Selenium WebDriver, you’ll start implementing and executing automated tests based on the created model. You will:

    • Understand how a model can be represented in the automated tests 
    • Get familiar with the open-source tools GraphWalker and AltWalker
    • Execute tests using AltWalker
    • Learn how to split and combine different models

    Learning Outcome

    • Visualizing the complexity of the app and the covered scenarios
    • Dealing with unclear specifications, especially when it comes to integrations, interactions between functionalities or modules
    • Generating large amounts of relevant and complex scenarios and covering them with automation
    • Maintaining regression tests
    • Dealing with flaky tests.

    Target Audience

    People who are already familiar with automation or coding; those with less programming experience can be paired with more experience teams and get support from peers.

    Prerequisites for Attendees

    To try the tests yourself, you will need a laptop with the following pre-installed:

    We will do the coding in groups, so not everyone needs to have this setup done, but it would be good to have it if you want to be able to follow everything yourself. 

    Links

    We will be using AltWalker: https://altwalker.github.io/altwalker/index.html which is based on Graphwalker (https://graphwalker.github.io/)
    Some articles about projects where we have used State Model Based testing:

  • Morning Break
  • Lunch Break
  • Afternoon Break
  • Opening Night Reception
  • 2023-03-29 09:10:00
    Invited
    Selenium: State of the Union
    Keynote

    What's the latest in the world of Selenium since the last SeleniumConf? In this talk, we'll cover Selenium 4, how the project is run, how you can participate, reminisce on the Old Days, and reflect on something that at first doesn't appear to be related to Selenium, yet is intimately related to it.

    Selenium: State of the Union

    What's the latest in the world of Selenium since the last SeleniumConf? In this talk, we'll cover Selenium 4, how the project is run, how you can participate, reminisce on the Old Days, and reflect on something that at first doesn't appear to be related to Selenium, yet is intimately related to it.

    Outline/Structure

    Selenium 4 and the future

     

    Learning Outcome

    All things happening in Selenium

     

    Target Audience

    All
  • 2023-03-29 10:05:00
    Invited
    Bigger Than The Box
    Keynote

    Has quality been put in a box? Has its focus and scope been narrowed to a single step in the delivery process? Has the role of quality in your organization been relegated to the test step, and its value beyond that diminished? Join Erika Chestnut as she shares how she breaks out of the box and crosses the aisles to elevate and expand the role quality in her organizations.  Learn how to influence from the middle, socialize the full potential of quality and cultivate a culture of quality defined, developed, and driven by Quality Champions.

    Bigger Than The Box

    Has quality been put in a box? Has its focus and scope been narrowed to a single step in the delivery process? Has the role of quality in your organization been relegated to the test step, and its value beyond that diminished? Join Erika Chestnut as she shares how she breaks out of the box and crosses the aisles to elevate and expand the role quality in her organizations.  Learn how to influence from the middle, socialize the full potential of quality and cultivate a culture of quality defined, developed, and driven by Quality Champions.

    Outline/Structure

    • Problem
      • Break down the vicious cycle of tech diminishing the value of the role of quality
      • Pros/Cons:  Pure test automation teams vs full stack quality engineering teams
    • Socialize Quality
      • Quality is not one size fits all - quality is not a single step
      • Quality opportunities are everywhere
    • Brand Quality 
      • Why?
      • How?
    • Champion Quality 
      • Influence from the left, right, and middle
      • Cross the aisles to build a culture of quality
      • Tell the story of quality: Metrics that matter vs mass destruction

    Learning Outcome

    By the end of this talk you’ll be able to:

    1. Socialize the full value of the quality team beyond the test step 
    2. Leverage creative ways to make quality approachable and memorable
    3. Confidently champion quality standards, processes, and policies in order to build a culture of quality 

    Target Audience

    All
  • 2023-03-29 16:10:00
    Invited
    Using A Proxy To Create A Full Stack Automation Suite
    Presentation

    To be able to create automation test cases using a frontend UI automation framework like Selenium or Appium is easy enough. The hundreds of test cases in your suite should give you a clear answer towards the health of your build. But what is the reality? The test suite has many failures that need hours of analysis to identify actual bugs vs. test case instabilities and false positives. Developers do not trust the automation and the QE feels testing manually would have been easier and faster.

    What is the solution? Rewrite your entire suite and reskill your entire team? The answer to converting your entire test suite to stable full stack automation test cases is simpler than you imagine. Our solution utilizes an open-source proxy solution to be able to record frontend and backend interaction while executing a frontend test case. The CI infrastructure then replays these recordings to be able to test frontend workflows without any dependency on backend services, which are prone to changes, time outs and outages. Results show stability of frontend test cases greatly improved without the added complexity of real time backend interaction. Our talk walks through what kind of test cases are best suited for this conversion, what considerations to make while choosing the proxy solution, how this should be configured, how CI should support this change and how to compliment the proxy tests to make sure backend services are healthy and working as expected. 

    Using A Proxy To Create A Full Stack Automation Suite

    To be able to create automation test cases using a frontend UI automation framework like Selenium or Appium is easy enough. The hundreds of test cases in your suite should give you a clear answer towards the health of your build. But what is the reality? The test suite has many failures that need hours of analysis to identify actual bugs vs. test case instabilities and false positives. Developers do not trust the automation and the QE feels testing manually would have been easier and faster.

    What is the solution? Rewrite your entire suite and reskill your entire team? The answer to converting your entire test suite to stable full stack automation test cases is simpler than you imagine. Our solution utilizes an open-source proxy solution to be able to record frontend and backend interaction while executing a frontend test case. The CI infrastructure then replays these recordings to be able to test frontend workflows without any dependency on backend services, which are prone to changes, time outs and outages. Results show stability of frontend test cases greatly improved without the added complexity of real time backend interaction. Our talk walks through what kind of test cases are best suited for this conversion, what considerations to make while choosing the proxy solution, how this should be configured, how CI should support this change and how to compliment the proxy tests to make sure backend services are healthy and working as expected. 

    Outline/Structure

    1. Outline maintainability and stability issues with automation suites that are front end only 
    2. Setting up a proxy to be able to record front end and back end interaction
    3. Work through the set up to break the back end interaction
    4. Integrate proxy in the middle to be able to replay the recordings for front end/back end interaction.
    5. Set up the API test suites to test the back end 
    6. Walk the audience through the usual CI set up to be able to achieve full stack automation with the existing Selenium test cases
    7. Recommendations on test case execution and maintenance 

    Learning Outcome

    • How to transform a test suite which is unstable and may often provide false positives.
    • How to set up a proxy for record and replay to emulate front end/back end interaction.
    • CI set up for automated execution and maintenance
    • API test suites to complete the back end integration  

    Target Audience

    SDET, Automation Engineers, Full Stack Engineers, Developers, Front End Engineers

    Prerequisites for Attendees

    Target audience should have a working knowledge of Selenium and how to create and maintain front end automation suites. Preferred but not required is working knowledge of API testing and proxy. 

    Links

    https://www.youtube.com/watch?v=wKzMiXj_2uM
    https://guildconferences.com/conference/automation-2020/ 
    https://www.youtube.com/watch?v=991NC2xWG0A&t=5s

  • 2023-03-29 11:35:00
    Final_Accepted
    Declarative UTAM Page Objects
    Deep Dive Session

    Page Objects design pattern is commonly used by most automation developers because it provides encapsulation and ensures maintainability of UI tests. The larger and more complex is application, the more UI tests teams have to write and maintain, and the more important it is to maintain 1:1 relations between UI component and a Page Object. But design pattern on its own does not ensure good quality of the page object code, that's why we created UTAM.

    UTAM provides declarative JSON based language to create page objects and compilers to transform declarative code to Java, JavaScript or TypeScript. Generated code is based on Selenium library (for Java) or WebdriverIO (for Javascript), but UTAM allows to build custom integration layer to use any framework for UI interactions. Generated code is high quality and uses all best practices like explicit waits and CSS selectors only (XPATH not supported). It's very easy to write UTAM JSON and even easier to generate it automatically from any HTML source.

    UTAM declarative language has support for mobile automation as well (both IOS and Android) and Shadow DOM.

    We provide extensive documentation and online interactive tutorials on UTAM web portal https://utam.dev/tutorial/introduction for better learning experience. We also created browser extension to partially generate UI tests https://chrome.google.com/webstore/detail/utam/llgodnekeleaidcljgfljjechnjdgnli 

    Our goal with UTAM is to increase maintainability of the page objects and development productivity to produce overall better experience.

    Declarative UTAM Page Objects

    Page Objects design pattern is commonly used by most automation developers because it provides encapsulation and ensures maintainability of UI tests. The larger and more complex is application, the more UI tests teams have to write and maintain, and the more important it is to maintain 1:1 relations between UI component and a Page Object. But design pattern on its own does not ensure good quality of the page object code, that's why we created UTAM.

    UTAM provides declarative JSON based language to create page objects and compilers to transform declarative code to Java, JavaScript or TypeScript. Generated code is based on Selenium library (for Java) or WebdriverIO (for Javascript), but UTAM allows to build custom integration layer to use any framework for UI interactions. Generated code is high quality and uses all best practices like explicit waits and CSS selectors only (XPATH not supported). It's very easy to write UTAM JSON and even easier to generate it automatically from any HTML source.

    UTAM declarative language has support for mobile automation as well (both IOS and Android) and Shadow DOM.

    We provide extensive documentation and online interactive tutorials on UTAM web portal https://utam.dev/tutorial/introduction for better learning experience. We also created browser extension to partially generate UI tests https://chrome.google.com/webstore/detail/utam/llgodnekeleaidcljgfljjechnjdgnli 

    Our goal with UTAM is to increase maintainability of the page objects and development productivity to produce overall better experience.

    Outline/Structure

    - Common problems in UI automation 

    - What is Page Objects design pattern, what problems it addresses and why should be used

    - UTAM is declarative language to create Page Objects in JSON format

    - Generating Java or JavaScript/TypeScript Page Objects from JSON

    - How UTAM affects development productivity, auto-generating UTAM Page Objects from HTML files

    - Examples of UI tests, UTAM supports mobile

    - How to start using UTAM, https://utam.dev and recipes in github

    Learning Outcome

    Audience will learn benefits of using Page Objects design pattern, how UTAM declaratively generates page objects from HTML and compile them into runnable Java or JavaScript code. Why UTAM increases development productivity.

    Target Audience

    Engineers who write UI automation tests with Java or JavaScript/TypeScript

    Prerequisites for Attendees

    Understand what is UI tests automation, experience in writing UI tests with Java or JavaScript

    Links

    - UTAM was presented in SauceCon 2022 https://saucecon.com/agenda-2022/ (last session May 5th)

    - Our website is https://utam.dev/ 

    - Some posts about UTAM https://twitter.com/PhilippeOzil/status/1524399230005264386 https://developer.salesforce.com/blogs/2022/05/run-end-to-end-tests-with-the-ui-test-automation-model-utam https://www.provartesting.com/blog/salesforce/top-4-dreamforce-21-announcements-for-testers/ 

    - Our open source repos https://github.com/salesforce/utam-java  https://github.com/salesforce/utam-recipes-js https://github.com/salesforce/utam-java-recipes 

    - Our artifacts https://www.npmjs.com/search?q=utam https://search.maven.org/search?q=utam 

  • 2023-03-29 14:50:00
    Final_Accepted
    Component Testing with WebdriverIO
    Presentation

    With more frontend frameworks on the rise web component testing becomes a crucial part of everyones testing stack. It allows to test various features of a single component of your UI and can help to reduce the amount of e2e around it that usually would run slower.

    There are already many component testing tools available but almost all of them miss an important feature: running the test in an actual browser. While one might argue that running test in a virtual DOM is fine for testing why not just run them in the browser if you can. With WebdriverIO v8 and its new browser runner capabilities, you can now execute unit or component tests directly in the browser with no complicated set-up required and use the power of the WebDriver protocol to seamlessly interact with them, as a user would do.

    In this session, Christian Bromann, Founding Engineer at Stateful, will tell you all about the new browser runner capabilities and will show case hands on live demos testing components in Vue, Svelte, React or Preact. Be amazed as component testing has never been so easy before!

    Component Testing with WebdriverIO

    With more frontend frameworks on the rise web component testing becomes a crucial part of everyones testing stack. It allows to test various features of a single component of your UI and can help to reduce the amount of e2e around it that usually would run slower.

    There are already many component testing tools available but almost all of them miss an important feature: running the test in an actual browser. While one might argue that running test in a virtual DOM is fine for testing why not just run them in the browser if you can. With WebdriverIO v8 and its new browser runner capabilities, you can now execute unit or component tests directly in the browser with no complicated set-up required and use the power of the WebDriver protocol to seamlessly interact with them, as a user would do.

    In this session, Christian Bromann, Founding Engineer at Stateful, will tell you all about the new browser runner capabilities and will show case hands on live demos testing components in Vue, Svelte, React or Preact. Be amazed as component testing has never been so easy before!

    Outline/Structure

    • Introduction into Web Components
    • Brief outline how web components work in different frameworks
    • introduction to the new WebdriverIO browser test-runner
    • live coding test examples for components in different frameworks

    Learning Outcome

    After the session everyone who attended (and pays attention) will know how to set up WebdriverIO's new browser runner to run efficient unit or component tests and will get a sense of what UI features one would want to do as part of quick component tests and which features should still be covered with an e2e test.

    Target Audience

    Anyone who joins the session can take a lot of valuable information out of it. As component testing can help to quickly validate a lot of features of a component in your UI it helps to reduce the amount of e2e tests.

    Prerequisites for Attendees

    Given that we are looking into component testing of frontend frameworks, some knowledge about writing frontend components in React, Svelte, Vue or Angular will be helpful to understand the context of this presentation. However as part of the presentation we will cover what web components are and how they look for individual frameworks.

    Links

    Videos of my public talks can be found here:
    https://www.youtube.com/watch?v=wYfqNXlqnC8&list=PLe6QWZ1xmeORQPCa2FxaRTKW0v_eIpnQz

    Slides to my previous talks can be found here:
    https://speakerdeck.com/christianbromann 

  • 2023-03-29 14:50:00
    Final_Accepted
    Building Quality Gates and Automated Decisions in CI/CD Pipelines. Lessons Learned with 200,000 Regressions.
    Presentation

    Today’s modern development disciplines -- whether Agile, Continuous Integration (CI) or Continuous Delivery (CD) -- have completely transformed how teams develop and deliver applications faster. But in order to compete in today’s fast-paced digital economy, companies must also test faster and test continuously. Teams must make fast and reliable decisions by tracking test results of thousands tests for hundreds of runs triggered by code changes. 

    But what if we could leverage Machine Learning to do the analysis and help team make rule-based decisions using a concept named Quality Gates?

    In this presentation, I will share learnings derived from regressions in 200,000 test cases, and how we use Machine Learning (ML) to triage failed reports and reduce team effort on results analysis. How we organized a Quality Gates and formed a rule-based engine to identify Go and No-Go decisions for a particular set. And how we automate release pipelines by use of meaningful feedback from the automated testing results.

    You will learn how to build Quality Gates in ReportPortal, how to integrate feedback within CI/CD pipelines. How to utilize ML analysis in triaging of failed reports. And finally make a leap forward to Continuous Testing.

    Building Quality Gates and Automated Decisions in CI/CD Pipelines. Lessons Learned with 200,000 Regressions.

    Today’s modern development disciplines -- whether Agile, Continuous Integration (CI) or Continuous Delivery (CD) -- have completely transformed how teams develop and deliver applications faster. But in order to compete in today’s fast-paced digital economy, companies must also test faster and test continuously. Teams must make fast and reliable decisions by tracking test results of thousands tests for hundreds of runs triggered by code changes. 

    But what if we could leverage Machine Learning to do the analysis and help team make rule-based decisions using a concept named Quality Gates?

    In this presentation, I will share learnings derived from regressions in 200,000 test cases, and how we use Machine Learning (ML) to triage failed reports and reduce team effort on results analysis. How we organized a Quality Gates and formed a rule-based engine to identify Go and No-Go decisions for a particular set. And how we automate release pipelines by use of meaningful feedback from the automated testing results.

    You will learn how to build Quality Gates in ReportPortal, how to integrate feedback within CI/CD pipelines. How to utilize ML analysis in triaging of failed reports. And finally make a leap forward to Continuous Testing.

    Outline/Structure

    1. Learnings and pain points derived from 200,000 regression sets
    2. Minimization of effort to triage failed reports
    3. Extension of automated test cases with attribute, related to components, priority, severity, flows
    4. Forming the dashboards for component health checks and environment checks
    5. Building Quality Gates based on rules and test case attributes.
    6. Organizing sequences of pipelines in Ci/CD tool based on automated QG decision
    7. Outcome and time savings

    Learning Outcome

    You will learn how to :

    1. Build Quality Gates in ReportPortal
    2. Integrate test automation feedback within CI/CD pipelines
    3. Extend automated test cases with attributes for detailed structuring
    4. Utilize ML analysis for triaging of failed reports

    Target Audience

    QA Managers, QA Leads, Testing team leads, mid - senior test automation engineers

    Links

    Also known as Dzmitry Humianiuk.

    Public Speaking experience:

  • 2023-03-29 12:25:00
    Final_Accepted
    Evolve Your Selenium Scripts Into Performance Scripts
    Presentation

    You have implemented your site functional tests with Selenium. Now, how can you reuse some of these tests to verify that your site does not only work as expected with 1 user, but with a big load of them? In this talk I will show you a way to achieve this without leaving your IDE.

    I will do a live demo generating a load script using JMeter DSL, from an existing Selenium script. Then, I will run it in combination with the Selenium script to generate load and evaluate user experience while such load is being imposed.

    Join me, add JMeter DSL to your toolbox and let's share some fun & ideas!

    Evolve Your Selenium Scripts Into Performance Scripts

    You have implemented your site functional tests with Selenium. Now, how can you reuse some of these tests to verify that your site does not only work as expected with 1 user, but with a big load of them? In this talk I will show you a way to achieve this without leaving your IDE.

    I will do a live demo generating a load script using JMeter DSL, from an existing Selenium script. Then, I will run it in combination with the Selenium script to generate load and evaluate user experience while such load is being imposed.

    Join me, add JMeter DSL to your toolbox and let's share some fun & ideas!

    Outline/Structure

    Here is a general outline of the presentation:

    • Quick review of an existing Selenium Test & Test App
    • Load test script generation using JMeter DSL
    • Selenium and JMeter DSL parallel automated execution
    • Results analysis
    • Summary
    • Q&A

    Learning Outcome

    We will review the basics of performance scripting, get to know JMeter DSL as a new tool for performance testing, a quick approach for creating performance tests from Selenium scripts and a nice way of reporting and reviewing load and user experience metrics! 

    Target Audience

    All

    Links

    The JMeter DSL site: https://abstracta.github.io/jmeter-java-dsl/

    Previous JMeter DSL articles and videos: https://github.com/abstracta/jmeter-java-dsl#articles--talks

    Some notable JMeter DSL presentations mentions: Apacheconf North America 2022, CMG PE & Devops 2022

  • 2023-03-29 14:00:00
    Final_Accepted
    Identifying Code Smells
    Presentation

    Code smells occur in the source code of an application and can indicate deeper problems that are not apparent at first glance. Identifying and fixing these issues helps tremendously in securing and future-proofing the application under development and allows developers and testers to better understand, maintain, extend, and test the code.

    In this session I will go through the different categories of code smells and explain each one with example code for each. Also, I will explain why it is good to know and be able to name different code smells even if you don’t do any programming yourself.

    Identifying Code Smells

    Code smells occur in the source code of an application and can indicate deeper problems that are not apparent at first glance. Identifying and fixing these issues helps tremendously in securing and future-proofing the application under development and allows developers and testers to better understand, maintain, extend, and test the code.

    In this session I will go through the different categories of code smells and explain each one with example code for each. Also, I will explain why it is good to know and be able to name different code smells even if you don’t do any programming yourself.

    Outline/Structure

    • What is a code smell?
    • Why is it beneficial to know about code smells?
    • Categories of code smells
    • Sample code for each code smell and explanation about their impact
    • Next steps to take after identifying code smells
    • Question & Answer

    Learning Outcome

    • Understand what code smells are and why they can be bad
    • Sharpen the senses to be able to recognize and name code smells
    • See why it is beneficial to know about code smells, even for testers that don’t do any programming

    Target Audience

    Testers, automation engineers, developers

    Prerequisites for Attendees

    A basic understanding of programming concepts would be helpful.

    Links

    My blog: https://softwaretester.blog
    Past and future events I spoke/speak at: https://www.softwaretester.blog/events

    Selection of past talks

  • 2023-03-29 16:10:00
    Final_Accepted
    Selenium Manager: Automated Driver & Browser Management for Selenium WebDriver
    Presentation

    Selenium WebDriver is an open source library that allows controlling web browsers (e.g., Chrome, Firefox, Edge, etc.) programmatically using different languages (such as Java, JavaScript, Python, Ruby, or C#). Internally, Selenium WebDriver uses the native support implemented by each browser to carry out the automation process. For this reason, we need to place a component called driver (e.g., chromedriver, geckodriver, msedgedriver, etc.) between the script using the Selenium WebDriver API and the browser. 

    Historically, the Selenium project did not cover the automated management (understood as the process of download, setup, and maintenance) of drivers. For this reason, different projects in the Selenium ecosystem emerged to do this task (such as WebDriverManager in Java or webdriver-manager in Python, among others). As of Selenium 4.6.0, automated driver management is shipped in Selenium WebDriver out of the box. This way, the driver management is done automatically and transparently for all Selenium WebDriver binding languages. This process is done through a new official tool of the Selenium portfolio called Selenium Manager.

    Selenium Manager is a CLI tool developed in Rust. It provides a robust mechanism to detect the version of the local browser to be controlled with Selenium WebDriver, download the proper driver, and make it available for Selenium WebDriver. Moreover, Selenium Manager has another relevant feature in its roadmap: the automatic management (i.e., download and installation) of browsers (such as Chrome, Firefox, or Edge).

    Selenium Manager has been built with the lessons learned from the development of WebDriverManager (first released in 2015). This way, the history of Selenium Manager is the history of how an independent third-party project has become part of the Selenium code development.

    Selenium Manager: Automated Driver & Browser Management for Selenium WebDriver

    Selenium WebDriver is an open source library that allows controlling web browsers (e.g., Chrome, Firefox, Edge, etc.) programmatically using different languages (such as Java, JavaScript, Python, Ruby, or C#). Internally, Selenium WebDriver uses the native support implemented by each browser to carry out the automation process. For this reason, we need to place a component called driver (e.g., chromedriver, geckodriver, msedgedriver, etc.) between the script using the Selenium WebDriver API and the browser. 

    Historically, the Selenium project did not cover the automated management (understood as the process of download, setup, and maintenance) of drivers. For this reason, different projects in the Selenium ecosystem emerged to do this task (such as WebDriverManager in Java or webdriver-manager in Python, among others). As of Selenium 4.6.0, automated driver management is shipped in Selenium WebDriver out of the box. This way, the driver management is done automatically and transparently for all Selenium WebDriver binding languages. This process is done through a new official tool of the Selenium portfolio called Selenium Manager.

    Selenium Manager is a CLI tool developed in Rust. It provides a robust mechanism to detect the version of the local browser to be controlled with Selenium WebDriver, download the proper driver, and make it available for Selenium WebDriver. Moreover, Selenium Manager has another relevant feature in its roadmap: the automatic management (i.e., download and installation) of browsers (such as Chrome, Firefox, or Edge).

    Selenium Manager has been built with the lessons learned from the development of WebDriverManager (first released in 2015). This way, the history of Selenium Manager is the history of how an independent third-party project has become part of the Selenium code development.

    Outline/Structure

    1. The history of Selenium Manager
    2. Automated driver management
      • Design and implementation in Rust
      • Integration with the binding languages
    3. Automated browser management
    4. Future work
    5. Summary and outlook

    Learning Outcome

    - Benefits of automated driver management (vs. manual)
    - Selenium Manager features: CLI tool, seamless integration with Selenium WebDriver

    Target Audience

    All Selenium developers.

    Links

    - Selenium Manager source code: https://github.com/SeleniumHQ/selenium/tree/trunk/rust
    - Author home page: https://bonigarcia.dev/

  • 2023-03-29 12:25:00
    Final_Accepted
    Creating Faster and More Reliable Web Tests with Blended Testing
    Deep Dive Session

    Automated acceptance tests are often implemented to exercise a fully-assembled and deployed system through its web interface. This approach makes them slow and flaky and reduces the value they could be bringing to your organisation.

    Blended Testing is a technique that can improve the speed and stability of web-based test scenarios by making them take shortcuts through other interfaces of the system under test.
    To use it effectively, though, we need to know when it's safe to take shortcuts and how to take them - this is where Task Analysis and the Screenplay Pattern can help.

    In this talk, Jan Molak - Lead Developer of Serenity/JS and co-author of "BDD in Action, Second Edtion" will show you how to apply Task Analysis, Screenplay Pattern, and use Serenity/JS 3.0 to design and develop blended test scenarios that exercise multiple interfaces of the system under test to improve execution speed and stability.

    Creating Faster and More Reliable Web Tests with Blended Testing

    Automated acceptance tests are often implemented to exercise a fully-assembled and deployed system through its web interface. This approach makes them slow and flaky and reduces the value they could be bringing to your organisation.

    Blended Testing is a technique that can improve the speed and stability of web-based test scenarios by making them take shortcuts through other interfaces of the system under test.
    To use it effectively, though, we need to know when it's safe to take shortcuts and how to take them - this is where Task Analysis and the Screenplay Pattern can help.

    In this talk, Jan Molak - Lead Developer of Serenity/JS and co-author of "BDD in Action, Second Edtion" will show you how to apply Task Analysis, Screenplay Pattern, and use Serenity/JS 3.0 to design and develop blended test scenarios that exercise multiple interfaces of the system under test to improve execution speed and stability.

    Outline/Structure

    In this practical session, we'll refactor a non-trivial web-based test to introduce business domain language and abstractions that help to swap out UI interactions for interactions with REST API.

    To do that:

    • We'll start with an example of a typical, non-trivial web test implemented using WebdriverIO
    • Introduce Task Analysis and use it to identify business domain-specific tasks (e.g. "add product to basket" vs "click on img tag")
    • Use Serenity/JS 3.0 Screenplay Pattern APIs to implement Web and REST API-specific flavours of those tasks (e.g. PopulateProductCatalogViaAPI vs PopulateProductCatalogViaUI)

    Learning Outcome

    By the end of the session, you'll be able to:

    • Explain how to use Task Analysis to identify business-focused tasks in a traditional spaghetti test script
    • Use Serenity/JS Screenplay Pattern APIs to turn the test script into a test scenario using business domain vocabulary
    • Use Serenity/JS Web and REST modules to implement blended tests

    Target Audience

    Test automation engineers, developers

    Prerequisites for Attendees

    A basic understanding of automating test scenarios interacting with Web-based interfaces and REST APIs.

    Links

    Serenity/JS 3.0 will be published in November 2022.

    Codebase: https://github.com/serenity-js

    Project website: https://serenity-js.org

  • 2023-03-29 17:00:00
    Final_Accepted
    Metrics to Make Your Quality Practices Effective
    Deep Dive Session

    Test Automation is considered the silver bullet that will enable teams to shift left and accomplish CI/CD. However, how confident are you with the value added by the automated tests in your organization and teams? Is your automation effective? Is it giving you the ROI you expected from it?

    Likewise, how comfortable are you with the testing approach of your team, and how is it helping improve your product quality?

    In the context of Quality, Testing, and Test Automation, for each role on the team, we will discuss the following:

    • What are effectiveness and ROI?
    • What are the commonly used metrics to measure effectiveness and ROI from your Testing & Test Automation activities? (Ex: code coverage, defect leakage, test execution status, test execution time, # of tests, etc.)
      • Do these metrics help in identifying blockers and root causes of issues?
      • How do these metrics help to make decisions to better product quality?
    • Discuss other metrics that can help each role make meaningful decisions to improve product quality!
      • Ex: Cycle Time, CLT, defect analysis with RCA, MTTR, Functional coverage, etc.
    Metrics to Make Your Quality Practices Effective

    Test Automation is considered the silver bullet that will enable teams to shift left and accomplish CI/CD. However, how confident are you with the value added by the automated tests in your organization and teams? Is your automation effective? Is it giving you the ROI you expected from it?

    Likewise, how comfortable are you with the testing approach of your team, and how is it helping improve your product quality?

    In the context of Quality, Testing, and Test Automation, for each role on the team, we will discuss the following:

    • What are effectiveness and ROI?
    • What are the commonly used metrics to measure effectiveness and ROI from your Testing & Test Automation activities? (Ex: code coverage, defect leakage, test execution status, test execution time, # of tests, etc.)
      • Do these metrics help in identifying blockers and root causes of issues?
      • How do these metrics help to make decisions to better product quality?
    • Discuss other metrics that can help each role make meaningful decisions to improve product quality!
      • Ex: Cycle Time, CLT, defect analysis with RCA, MTTR, Functional coverage, etc.

    Outline/Structure

    • Getting on the same page - understand commonly used terminology - 5 min
    • Discuss with participants the metrics used in their teams / organizations to understand effectiveness of testing and automation - 10 min
    • Discuss the metrics in the context of the team / organization - 5 min
    • A fresh look at metrics that can help different roles on the team understand the state of automation and quality of the product - 10 min
    • A few practices that will help in increasing the ROI for automation - 10 min
    • Q&A

    Learning Outcome

    • Using metrics blindly, without context, does not help the team take decisions to improve the quality of the product
    • Each role on the team may need a different set of metrics to understand the current situation w.r.t. automation and quality of the product.
    • A reference set of metrics that can be used for each role

    Target Audience

    SDET, QA, Test Automation Engineer, Developers, Test Leads, Test Managers

    Prerequisites for Attendees

    None

  • 2023-03-29 17:00:00
    Final_Accepted
    Python Selenium: Fundamentals to Frameworks (with SeleniumBase)
    Deep Dive Session

    Do you love Python? The WebDriver Ecosystem has you covered! With millions of downloads from the Python Package Index, (and growing), the Selenium Python bindings are a popular option for automation engineers worldwide.

    This deep-dive session will kick-off with a demonstration of Python Selenium fundamentals. From there, we'll transition into improving on the fundamentals by using a test framework, SeleniumBase, which builds on top of pytest and other popular Python unit-testing frameworks.

    Why use a test framework with Selenium? Selenium was designed to be a browser automation library... not a test framework, which can add useful features and improve on existing functionality.

    Disadvantages of using raw Selenium without additional libraries or frameworks:

    • The default timeout is 0: If an element isn't immediately ready to be interacted with, you'll get errors when trying to interact with those elements.
    • The command statements can get a bit too long for performing a basic action. Eg: `self.driver.find_element(By.CSS_SELECTOR, CSS_SELECTOR).click()` to click an element, which can be simplified.
    • No HTML reports, dashboards, results, automatic screenshots, etc.
    • No driver management: Eg. If chromedriver isn't on your system path when calling driver.Chrome(), you'll get errors. (This may change soon!)
    • No command-line options for changing default Selenium behavior or adding more functionality.
    • No advanced tools included, such as recorders, test-runners, etc.

    A test framework can improve on that list!

    Sometimes people choose to build their own frameworks: If that's you, you'll learn about how to do that more easily. Sometimes people choose to use an existing framework: If that's you, you'll learn about an existing one, (SeleniumBase), which may have all the features you're looking for.

    Python Selenium: Fundamentals to Frameworks (with SeleniumBase)

    Do you love Python? The WebDriver Ecosystem has you covered! With millions of downloads from the Python Package Index, (and growing), the Selenium Python bindings are a popular option for automation engineers worldwide.

    This deep-dive session will kick-off with a demonstration of Python Selenium fundamentals. From there, we'll transition into improving on the fundamentals by using a test framework, SeleniumBase, which builds on top of pytest and other popular Python unit-testing frameworks.

    Why use a test framework with Selenium? Selenium was designed to be a browser automation library... not a test framework, which can add useful features and improve on existing functionality.

    Disadvantages of using raw Selenium without additional libraries or frameworks:

    • The default timeout is 0: If an element isn't immediately ready to be interacted with, you'll get errors when trying to interact with those elements.
    • The command statements can get a bit too long for performing a basic action. Eg: `self.driver.find_element(By.CSS_SELECTOR, CSS_SELECTOR).click()` to click an element, which can be simplified.
    • No HTML reports, dashboards, results, automatic screenshots, etc.
    • No driver management: Eg. If chromedriver isn't on your system path when calling driver.Chrome(), you'll get errors. (This may change soon!)
    • No command-line options for changing default Selenium behavior or adding more functionality.
    • No advanced tools included, such as recorders, test-runners, etc.

    A test framework can improve on that list!

    Sometimes people choose to build their own frameworks: If that's you, you'll learn about how to do that more easily. Sometimes people choose to use an existing framework: If that's you, you'll learn about an existing one, (SeleniumBase), which may have all the features you're looking for.

    Outline/Structure

    Live demos and examples of Python automation scripts the whole way! Most examples can be found in the SeleniumBase examples folder: https://github.com/seleniumbase/SeleniumBase/tree/master/examples

    Things that will get covered:

    • Python Selenium fundamentals.
    • Generic ways for test frameworks to improve on the fundamentals.
    • Using SeleniumBase as a framework to make Python Selenium testing easier.

    There will be multiple examples from https://github.com/seleniumbase/SeleniumBase/tree/master/examples/migration/raw_selenium, which demonstrate various ways to improve on raw Selenium without additional libraries.

    Learning Outcome

    You'll jump from learning the basics to mastering advancing Python automation techniques in under an hour.

    Target Audience

    Python enthusiasts

    Prerequisites for Attendees

    Basic knowledge of Python

    Links

    https://confengine.com/conferences/selenium-conf-2022/proposal/16748/solving-wordle-with-python-and-selenium-and-then-running-that-in-github-actions

    https://sessionize.com/michael-mintz/

    https://dev.to/mintzworld/solving-the-wordle-game-using-python-and-selenium-1aei

    https://seleniumbase.com/the-ultimate-pytest-debugging-guide-2021/

     

  • 2023-03-29 11:35:00
    Final_Accepted
    Selenium Grid Deployment Alternatives: Scaling and Adding Video Recording Without Container Orchestration
    Deep Dive Session

    Selenium Grid and Docker Selenium are great testing tools, but how do you deploy them at scale across an organization where you can't use Docker Swarm or Kubernetes for orchestration?

    In this deep dive, I’ll discuss the basics of setting up a Selenium Grid and the custom services you'll need to scale it up to 100+ nodes with per-test video recording and autoscaling.  As a real world example, you’ll see how single use nodes can be used to ensure a sterile test environment.

    Selenium Grid Deployment Alternatives: Scaling and Adding Video Recording Without Container Orchestration

    Selenium Grid and Docker Selenium are great testing tools, but how do you deploy them at scale across an organization where you can't use Docker Swarm or Kubernetes for orchestration?

    In this deep dive, I’ll discuss the basics of setting up a Selenium Grid and the custom services you'll need to scale it up to 100+ nodes with per-test video recording and autoscaling.  As a real world example, you’ll see how single use nodes can be used to ensure a sterile test environment.

    Outline/Structure

    • Deploying a fully distributed Grid to the cloud
      • How to make all components talk to each other
      • Making the Grid "self-healing" to comply with continuous deployment
    • Registering a single node
    • Configuring nodes to run only a single test
      • How this ensures test environment sterility
    • Video recording with a single node
      • Challenges of video recording when nodes run on different VMs, without Docker Swarm
      • Launching a node and video container alongside each other and making them talk
      • How video recording works without any modification
      • How it's configured to work in the specific environment needed
    • Scaling nodes
      • How the node and video container's host is structured, and how it is reused after each test
      • Keeping nodes that are running tests from being deleted on scale-in
      • Launching a node and video container alongside each other 
      • Metrics used for scaling
      • How the autoscaler works
    • Queueing tests
      • Challenges faced when tests are run from an automation tool (not pushed locally from developer computers)
      • "zombie nodes" - when a test in the queue gets a session, but has already been abandoned
      • Orchestrating all timeouts to ensure a "zombie node" situation does not occur
      • Ensuring queue time is longer than cold start time of a node

    Learning Outcome

    An understanding for how Selenium Grid is deployed at scale and what issues are commonly encountered.

    Target Audience

    Participants looking to gain in-depth knowledge of a cloud based, scalable grid deployment

    Prerequisites for Attendees

    A basic comprehension of Selenium Grid, or a curiosity for how it is managed at scale.

  • 2023-03-29 14:00:00
    Final_Accepted
    What’s New and Good in Selenium
    Presentation

    Selenium 4 and the subsequent smaller 4.x releases have brought a few changes and a lot of great new features into the framework. We now have relative selectors for identifying page elements; the BiDi API/Chrome DevTools functionality to perform such tasks as emulating devices or capturing network requests; but there are also updates on how you can work with multiple windows or use the Actions API in your tests. I will show you all of these plus more to help you be up to date with the goodness of the Selenium framework.

    What’s New and Good in Selenium

    Selenium 4 and the subsequent smaller 4.x releases have brought a few changes and a lot of great new features into the framework. We now have relative selectors for identifying page elements; the BiDi API/Chrome DevTools functionality to perform such tasks as emulating devices or capturing network requests; but there are also updates on how you can work with multiple windows or use the Actions API in your tests. I will show you all of these plus more to help you be up to date with the goodness of the Selenium framework.

    Outline/Structure

    I will present a list of new features or updates introduced in latest Selenium versions. Depending on how many there will be, i will allocate appropriate time to discuss (and show examples) for each of them. Smaller updates (like what's new regarding working with multiple windows) will take less time. I will focus more on larger topics (like BiDi or Grid).

    Learning Outcome

    What are the newly available features and how to use them in tests. What are some updates to existing functionality and how to update corresponding tests.

    Target Audience

    Testers writing automation
  • Morning Break
  • Lunch Break
  • Craft Beer Break
  • 2023-03-30 09:05:00
    Invited
    What Exactly Do You Do in Test Automation?
    Keynote

    If you took the time to sit down to answer the question “what do you do as an Automator on a daily, weekly or monthly basis”, what would you come up with? Would it just be coding, coding and more coding or would your answers highlight a wide and wonderful range of activities you carry out?

    For a skilled Automator, success relies on more than just being comfortable with programming languages and tools. It requires a diverse range of skills, techniques and experiences which the newly released Ministry of Testing automation curriculum has captured and organised in a way so that everyone can see the abilities an Automator has or can attain.

    In this talk, Mark will share how his own experiences and the experiences of other automators have helped curate the Ministry of Testing automation curriculum. Through these stories, we’ll learn how the journey of an Automator is a varied one that can easily employ pen, paper and questions as much as IDEs, frameworks and libraries. We’ll also learn how an open source community curated curriculum can help you regardless of your abilities, role and context and how you can help it grow by sharing your own experience.

    What Exactly Do You Do in Test Automation?

    If you took the time to sit down to answer the question “what do you do as an Automator on a daily, weekly or monthly basis”, what would you come up with? Would it just be coding, coding and more coding or would your answers highlight a wide and wonderful range of activities you carry out?

    For a skilled Automator, success relies on more than just being comfortable with programming languages and tools. It requires a diverse range of skills, techniques and experiences which the newly released Ministry of Testing automation curriculum has captured and organised in a way so that everyone can see the abilities an Automator has or can attain.

    In this talk, Mark will share how his own experiences and the experiences of other automators have helped curate the Ministry of Testing automation curriculum. Through these stories, we’ll learn how the journey of an Automator is a varied one that can easily employ pen, paper and questions as much as IDEs, frameworks and libraries. We’ll also learn how an open source community curated curriculum can help you regardless of your abilities, role and context and how you can help it grow by sharing your own experience.

    Outline/Structure

    The talk will start by introducing the current challenges with how we see ourselves as Automators and what we do. We'll look at how the impacts training, hiring and discourse around Automation as a topic. Then we'll learn about the Ministry of Testing automation curriculum and explore some stories that illustrate why, as Automators, we do more than code scripts and tests. Finally, we conclude with an invitation to the audience to share their experiences to help improve the curriculum for the future.

    Learning Outcome

    By the end of this talk you’ll be able to:

    • Relate to the experiences of automators and their responsibilities
    • Outline the diverse range of skills, knowledge and techniques and Automator requires
    • Share your own experiences to support a community-curated curriculum for automators

    Target Audience

    All
  • 2023-03-30 16:10:00
    Invited
    Q & A with the Selenium Committer's Panel
    Keynote

    Q & A with the Selenium Committer's Panel moderated by Noemi Ferrara.

    Q & A with the Selenium Committer's Panel

    Q & A with the Selenium Committer's Panel moderated by Noemi Ferrara.

    Outline/Structure

    Moderated Q&A panel session with core contributors to the Selenium Project.

    Learning Outcome

    Learn what's to come in future releases of Selenium and WebDriver.

    Target Audience

    All

    Prerequisites for Attendees

    No prerequisites, just bring your questions!

  • 2023-03-30 11:30:00
    Invited
    Testing with Real Robots over the Internet: What Could Go Wrong?
    Deep Dive Session

    When I started the Selenium project, I'd frequently describe Selenium as "like a robot" that is trapped inside your computer. For the past 11+ years, I've been testing that metaphor by building real mechanical robots for testing apps and devices, pushing the definition of "end" in end-to-end testing. Lately, I've been remotely controlling these robot over the internet, and learned some lessons I'd like to share. In this talk, I'll compare and contrast how testing with a physical robot over the internet is different than traditional testing approaches with Selenium or Appium.

    Testing with Real Robots over the Internet: What Could Go Wrong?

    When I started the Selenium project, I'd frequently describe Selenium as "like a robot" that is trapped inside your computer. For the past 11+ years, I've been testing that metaphor by building real mechanical robots for testing apps and devices, pushing the definition of "end" in end-to-end testing. Lately, I've been remotely controlling these robot over the internet, and learned some lessons I'd like to share. In this talk, I'll compare and contrast how testing with a physical robot over the internet is different than traditional testing approaches with Selenium or Appium.

    Outline/Structure

    • Overview of telerobotics and telepresence
    • Why test with physical robots vs traditional approaches
    • How testing with physical robots is different
      • Motors
      • Sensors
      • Cameras
      • Object locator strategies:
        • "Traditional" approaches with OpenCV
        • "AI" approaches with machine learning
    • Challenges of testing with robots
      • Lighting
      • Latency
      • Mechanical wear and tear
      • Skills required
      • "Does it scale?"
    • Future work

    Learning Outcome

    Understanding of the costs, benefits, challenges, and opportunities of testing with robots.

    Target Audience

    All

    Prerequisites for Attendees

    Attendees should have a general interest in mobile testing and robots.

    Links

    Keynote - Don't Fear The Robot by Jason Huggins | AppiumConf Bengaluru 2019

    Appium: The Untold Story - Dan Cuellar & Jason Huggins | AppiumConf London 2018

    Robots: The Nuclear Option | SeleniumConf London 2016

    Fixing HealthCare.gov, One Test at a Time | Selenium Meetup San Francisco 2015

    World Domination: Next Steps | SeleniumConf Portland 2015

    Teaching a Robot to Play Angry Birds | SeleniumConf London 2012 

  • 2023-03-30 13:05:00
    Invited
    Solving Unemployment in Africa with Testing and Selenium
    Presentation

    Four years working as a tester in a consulting company, I had learned enough to do well on my job. I knew something called automation but had yet to work on it. Looking around for learning led to realizing there were few people to learn from as unemployment in Africa was blocking access to people with experience. I started teaching and learning through teaching.

    Now 1000+ students later, I teach a basic course on testing introducing automation with java+selenium and an intermediate course with js/java/python with Selenium, Appium, and rest APIs. The market wants automation testers. Automation has become paramount. 

    This talk discusses my dream of removing unemployment in Africa through software testing. Realizing the dream starts with one person, teaching many. Many then speak of their life-changing experiences of joining tech. It’s a story of a hobby on the side of testing work, growing into a training business, and learning automation and Selenium with the students I have taught. 

    Selenium has been a game changer for people. During the Testify programs, Selenium has played a massive role in benching the wheel of test automation, which has helped several novices navigate the waters of automation easily. Join me in ensuring that by 2030, every graduate in Africa no longer has to worry about unemployment through testing and also how Selenium sits at the heart of this very solution.

    Solving Unemployment in Africa with Testing and Selenium

    Four years working as a tester in a consulting company, I had learned enough to do well on my job. I knew something called automation but had yet to work on it. Looking around for learning led to realizing there were few people to learn from as unemployment in Africa was blocking access to people with experience. I started teaching and learning through teaching.

    Now 1000+ students later, I teach a basic course on testing introducing automation with java+selenium and an intermediate course with js/java/python with Selenium, Appium, and rest APIs. The market wants automation testers. Automation has become paramount. 

    This talk discusses my dream of removing unemployment in Africa through software testing. Realizing the dream starts with one person, teaching many. Many then speak of their life-changing experiences of joining tech. It’s a story of a hobby on the side of testing work, growing into a training business, and learning automation and Selenium with the students I have taught. 

    Selenium has been a game changer for people. During the Testify programs, Selenium has played a massive role in benching the wheel of test automation, which has helped several novices navigate the waters of automation easily. Join me in ensuring that by 2030, every graduate in Africa no longer has to worry about unemployment through testing and also how Selenium sits at the heart of this very solution.

    Outline/Structure

    -

    Learning Outcome

    -

    Target Audience

    testers, automation engineers, developers, managers

    Prerequisites for Attendees

    -

  • 2023-03-30 14:45:00
    Invited
    Lightning Talks
    Presentation

    A little history .... Dan Cuellar was selected to speak at Selenium Conference 2012 in London about an entirely different topic. As part of his presentation, he showed off iOS Automation using Selenium syntax to demonstrate writing platform-agnostic tests that use separate platform-specific page objects with a common interface. To his surprise, the cool test architecture would take a backseat to the spectacle of iOS tests running like WebDriver tests. Several people suggested that he give a lightning talk later in the conference to explain exactly how it worked.

    On the second day of the conference, Dan stepped up on stage to give the lightning talk. Jason Huggins, co-creator of Selenium, moderated the lightning talks. Dan experienced technical difficulties getting his presentation to load, and Jason nearly had to move on to the next talk. At the last moment, the screen turned on and Dan jumped into his presentation. He explained the details of his implementation and how it worked, begged for contributors, and in five minutes it was over. The crowd applauded politely, and he left the stage.

    If we look at how Appium came into existence, lightning talks are a very important part of this journey. Continuing the tradition at SeleniumConf Chicago 2023, we will be offering a Lightning Talk track session. Each presenter will be given a maximum of 5 minutes for their talk. Here's how it works: on the first day of the conference there will be a sign-up board for any attendee to write down their topic and contact information. All attendees will be encouraged throughout the day to stop by the board and add a tick mark to upvote the talk(s) they'd like to hear. Once voting has ended, the organizers will track down the top 6-7 vote getters and provide additional details to help them prepare for their talk.

    Lightning Talks

    A little history .... Dan Cuellar was selected to speak at Selenium Conference 2012 in London about an entirely different topic. As part of his presentation, he showed off iOS Automation using Selenium syntax to demonstrate writing platform-agnostic tests that use separate platform-specific page objects with a common interface. To his surprise, the cool test architecture would take a backseat to the spectacle of iOS tests running like WebDriver tests. Several people suggested that he give a lightning talk later in the conference to explain exactly how it worked.

    On the second day of the conference, Dan stepped up on stage to give the lightning talk. Jason Huggins, co-creator of Selenium, moderated the lightning talks. Dan experienced technical difficulties getting his presentation to load, and Jason nearly had to move on to the next talk. At the last moment, the screen turned on and Dan jumped into his presentation. He explained the details of his implementation and how it worked, begged for contributors, and in five minutes it was over. The crowd applauded politely, and he left the stage.

    If we look at how Appium came into existence, lightning talks are a very important part of this journey. Continuing the tradition at SeleniumConf Chicago 2023, we will be offering a Lightning Talk track session. Each presenter will be given a maximum of 5 minutes for their talk. Here's how it works: on the first day of the conference there will be a sign-up board for any attendee to write down their topic and contact information. All attendees will be encouraged throughout the day to stop by the board and add a tick mark to upvote the talk(s) they'd like to hear. Once voting has ended, the organizers will track down the top 6-7 vote getters and provide additional details to help them prepare for their talk.

    Outline/Structure

    • Introduction and overview of how lightning talks will work - 5 mins
    • 6-7 most upvoted submissions will get 5 minutes to present their topic - 35 mins
    • Huzzahs and congratulations will reverberate throughout the venue

    Learning Outcome

       

    Target Audience

    All
  • 2023-03-30 13:05:00
    Final_Accepted
    Managing the Test Data Nightmare
    Deep Dive Session

    Good data for testing can be a nightmare to manage. Sometimes, teams don’t have much control over the data in their systems under test—it’s just dropped in, and it can change arbitrarily. Other times, teams need to build their own data sets, either before testing or during testing. Inaccurate data can leave test gaps. Incorrect or stale data can break tests. Large data can consume too much time. Ugh!

    In this talk, we’ll cover strategies for defeating many types of test data nightmares:

    • recognizing the difference between product data and test case data
    • deciding when to prepare data statically beforehand or dynamically during testing
    • using data to control how tests run or reflect product state
    • hard-coding values versus discovering data in the system
    • avoiding collisions on shared data

    The strategies we cover can be applied to any project in any language. After this talk, you will wake up from the nightmare and handle test data cleanly and efficiently like a pro!

    Managing the Test Data Nightmare

    Good data for testing can be a nightmare to manage. Sometimes, teams don’t have much control over the data in their systems under test—it’s just dropped in, and it can change arbitrarily. Other times, teams need to build their own data sets, either before testing or during testing. Inaccurate data can leave test gaps. Incorrect or stale data can break tests. Large data can consume too much time. Ugh!

    In this talk, we’ll cover strategies for defeating many types of test data nightmares:

    • recognizing the difference between product data and test case data
    • deciding when to prepare data statically beforehand or dynamically during testing
    • using data to control how tests run or reflect product state
    • hard-coding values versus discovering data in the system
    • avoiding collisions on shared data

    The strategies we cover can be applied to any project in any language. After this talk, you will wake up from the nightmare and handle test data cleanly and efficiently like a pro!

    Outline/Structure

    1. Introduce an app for testing
      1. Point out the data it needs
      2. Differentiate product data from test case data
    2. Product data
      1. Static data prep strategies
      2. Dynamic data prep strategies
    3. Test case data
      1. Test case literals
      2. Output references
      3. Input references
      4. Discovering data in the system
    4. Collisions
      1. These happen when test collide on shared data
      2. How to avoid collisions

    Learning Outcome

    1. To recognize that test data is just as important as test cases and test code.
    2. To nuance the difference between product data existing in the environment under test and test case data existing for the testing and automation.
    3. To learn multiple helpful strategies for managing whatever test data nightmare you may be facing.

    Target Audience

    Testers, Developers, Automation Engineers, SDETs, Testing Managers

    Prerequisites for Attendees

    Attendees should be familiar with how web apps work, including data layers.

    Links

    My blog: https://automationpanda.com/

    My speaking: https://automationpanda.com/speaking/

    Article about this topic: https://automationpanda.com/2021/05/03/managing-the-test-data-nightmare/ 

  • 2023-03-30 10:40:00
    Final_Accepted
    Why Browser Engines ≠ Real Desktop Browsers ≠ Mobile Browsers
    Presentation

    All of us have tested on either headless browsers, browser engines or responsive mode for mobile. However, there are a lot of differences between an actual browser, desktop and mobile, vs a simulated one.

    In this talk I’ll walk you through real world examples that show you the gaps you can miss while testing:

    1. In headless mode

    2. Browser engines

    3. Responsive mode for mobile browsers

    I’ll also share the technicalities of why this happens and my learnings from having worked on a browser engine.

    Why Browser Engines ≠ Real Desktop Browsers ≠ Mobile Browsers

    All of us have tested on either headless browsers, browser engines or responsive mode for mobile. However, there are a lot of differences between an actual browser, desktop and mobile, vs a simulated one.

    In this talk I’ll walk you through real world examples that show you the gaps you can miss while testing:

    1. In headless mode

    2. Browser engines

    3. Responsive mode for mobile browsers

    I’ll also share the technicalities of why this happens and my learnings from having worked on a browser engine.

    Outline/Structure

    • Levels of ‘real-user’ testing - 5 mins

    • Headless vs headful testing: Technicalities and examples - 10 mins

    • Browser engines vs real browsers: Technicalities and examples - 10 mins

    • Real mobile browsers vs simulated browsers: Technicalities and examples - 10 mins

    • Q&A - 10 mins

    Learning Outcome

    • Different environments for testsing and their pros and cons

    • Choosing the ideal environment for your next project depending on the functionality

    • Differences between headless and headful testing, browser engines and real browsers, real mobile browsers and simulated browsers

    Target Audience

    QA, SDETs, Engineering Managers, QA Managers

    Prerequisites for Attendees

    None

    Links

  • 2023-03-30 13:55:00
    Final_Accepted
    Do You Use Selenium Only for Test Automation?
    Presentation

    If you answered “yes” to the question, then welcome to a world where we will discuss the non-testing use cases for our dear driver (pun intended).  

    In this session, we will break the mould, and discuss the various use cases for our browser automation tool. We will start with testing but go on to demonstrate how you can build a poor man’s version of RPA (Robotic Process Automation) tool with a little code.

    Do You Use Selenium Only for Test Automation?

    If you answered “yes” to the question, then welcome to a world where we will discuss the non-testing use cases for our dear driver (pun intended).  

    In this session, we will break the mould, and discuss the various use cases for our browser automation tool. We will start with testing but go on to demonstrate how you can build a poor man’s version of RPA (Robotic Process Automation) tool with a little code.

    Outline/Structure

    Fun fact: Selenium’s official website explicitly mentions that “Selenium automates browsers. That's it!” And while many of us might not be aware of the other interesting use cases, Selenium and the WebDriver API can actually be used for a lot of repetitive jobs, which require humans and system interaction.

    1. We will acclimatize the audience by discussing the common use cases for Selenium
    2. We switch things into second gear, by displaying how Selenium can be an integral part of your Performance testing strategy
    3. Over and above testing, can we use Selenium and its siblings for automating mundane tasks like admin updates, site maintenance, reporting or holiday shopping?
    4. Explain the problem statement of automating desktop application from personal experience
    5. Switch things into top gear and show how we used Selenium and its siblings to create a poor man’s version of an RPA tool and automated Oracle ADFDI plugin for Excel
    6. Keep the conversation balanced by understanding what is a good use case versus a bad use case for automation
    7. Q&A from Audience

     


     

    I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times.- Bruce Lee.

    The same applies to tools, so while it helps to know a lot of automation tools (like Cypress, Playwright, Selenium and others), what would really help is get exposure to the various use cases for using automation and understand, where it is good fit and where it is not.

    Learning Outcome

    Broaden the audience’s mindset to look for various applications of Selenium and system automation in general. 

    Target Audience

    SDET, QA, Testers, Test Managers , Test Consultants

    Prerequisites for Attendees

    Users should understand basic usage of Selenium

    Links

    Earlier presentations and publications: 
    1. Seconf 2016 - https://youtu.be/HSABgUKpu2E
    2. Seconf 2022 - https://youtu.be/KLN4bHND0nM
    3. Publications on LeadDev :
      1. https://leaddev.com/skills-new-managers/everything-you-need-know-when-transitioning-ic-manager
      2. https://leaddev.com/career-paths-progression-promotion/what-top-companies-are-looking-great-remote-technical-interview
    4. Publication on Quality matters article : https://quality-matters.org/index.php?page=qm-issues-archive&issue=14
    5. Publication on Salesforceben : https://www.salesforceben.com/open-source-code-based-framework-to-automate-salesforce-testing/
  • 2023-03-30 11:30:00
    Final_Accepted
    Selenium in the Clouds: Using Cloud Service Providers with Selenium WebDriver
    Presentation

    People all around the world love using Selenium to drive browsers for all sorts of reasons. Running Selenium scripts on a local device is fast and can be done easily from a developer's workstation. 

    Some teams, however, need to run scripts on cloud providers such as Sauce Labs, BrowserStack or LambdaTest. Reasons including running scripts on cross-browser environments for test automation and reducing dependencies on a particular developer's environment are typically why folks move their scripts and tests to cloud providers. While moving existing tests and scripts to run on cloud providers is relatively straightforward, teams often notice big differences between local and cloud-provider execution and script maintenance. Some of the differences are totally expected. Some are not.

    In this talk, I'll discuss my experiences with helping teams use Sauce Labs with cloud providers, including

    • Some common pitfalls teams encounter with using cloud providers for the first time,
    • How using a cloud provider platform differs from using local devices, and
    • Approaches teams can take to optimize for running tests in the cloud.

    This talk will be informed by my experience using Selenium and Appium, and will be as platform-agnostic as possible.

    Selenium in the Clouds: Using Cloud Service Providers with Selenium WebDriver

    People all around the world love using Selenium to drive browsers for all sorts of reasons. Running Selenium scripts on a local device is fast and can be done easily from a developer's workstation. 

    Some teams, however, need to run scripts on cloud providers such as Sauce Labs, BrowserStack or LambdaTest. Reasons including running scripts on cross-browser environments for test automation and reducing dependencies on a particular developer's environment are typically why folks move their scripts and tests to cloud providers. While moving existing tests and scripts to run on cloud providers is relatively straightforward, teams often notice big differences between local and cloud-provider execution and script maintenance. Some of the differences are totally expected. Some are not.

    In this talk, I'll discuss my experiences with helping teams use Sauce Labs with cloud providers, including

    • Some common pitfalls teams encounter with using cloud providers for the first time,
    • How using a cloud provider platform differs from using local devices, and
    • Approaches teams can take to optimize for running tests in the cloud.

    This talk will be informed by my experience using Selenium and Appium, and will be as platform-agnostic as possible.

    Outline/Structure

    This presentation will be done in a lecture-style "Lessons Learned" format with the following five sections.

    What is a Cloud Service? Describing the differences between using a local browser, an in-house grid and a cloud-service.

    Connecting Tests to a Session on a Cloud Service. How to connect your Selenium tests to a remote driver instance, how this happens typically with cloud-services, and what to keep in mind when setting options/capabilities in a cloud-service. 

    Running Tests on a Cloud Service. What to expect when you run tests on a cloud-service environment in terms of execution time and generating test logs and assets. Also there is some discussion of how to optimize tests for running in cloud-based environments.

    Stopping a Session on a Cloud Service. Some ideas of what happens when a cloud-based browser session is finished and/or completes. Also I'll mention some best practices to make sure cloud-based tests don't more cost time or money than they need to.

    Conclusions / Lessons Learned

    Learning Outcome

    After this presentation, attendees will learn

    • What are the differences between running scripts with Selenium locally versus on a cloud-provider,
    • How to optimize scripts for use with a cloud-provider, and
    • What are the benefits and costs of using a cloud-provider versus using other execution environments.

    Target Audience

    Testers and developers who have or are using a cloud service in addition to writing Selenium-based test frameworks.

    Prerequisites for Attendees

    For this talk, you should be familiar with:

    • A basic understanding of how the Selenium WebDriver works, and
    • A basic understanding of the difference between using the WebDriver locally and using the RemoteWebDriver.

    Experience with writing automated tests and scripts would be helpful, but not required.

    Links

    https://simplythetest.tumblr.com - My blog, which you may read as you wish.

  • 2023-03-30 13:55:00
    Final_Accepted
    WebDriver BiDi + Selenium. Why and How?
    Presentation

    We are presenting a hands-on talk with demonstrating Selenium work over WebDriver BiDi to ChromeDriver.

    1. Short introduction into WebDriver BiDi
    2. Hands-on demonstration
    WebDriver BiDi + Selenium. Why and How?

    We are presenting a hands-on talk with demonstrating Selenium work over WebDriver BiDi to ChromeDriver.

    1. Short introduction into WebDriver BiDi
    2. Hands-on demonstration

    Outline/Structure

    1. Overview of the WebDriver BiDi and its possibilities.
    2. Update on current implementation status.
    3. Presentation of the Selenium working over WebDriver BiDi.

    Learning Outcome

    Attendees will learn about WebDriver BiDi, how it can be used in Selenium, and what advantages it could provide to them.

    Target Audience

    Automation tooling developers, Web developers, QA engineers

    Prerequisites for Attendees

    Recommended pre-reading https://developer.chrome.com/blog/webdriver-bidi/

    Links

    1. [Blogpost] WebDriver BiDi - The future of cross-browser automation: https://developer.chrome.com/blog/webdriver-bidi/
    2. [Selenium Conf 2022] WebDriver BiDi: work in progress. by Maksim Sadym: https://youtu.be/ehPpDgqc2bE
    3. [Breakpoint 2021] WebDriver BiDi  https://youtu.be/8k4-8-mMXs4
  • 2023-03-30 10:40:00
    Final_Accepted
    UNTestable: It's Just Pressing a Button, How Hard Could it Be?
    Deep Dive Session

    Over the last 7 years, I've consulted several testing teams on test automation projects for their web applications, and the most frequent troubleshooting request I get is about clicking some button on some website.

    It's just pressing a button... how hard could it be... right?

    I came to discover there's many edge cases when it comes to simply executing a click on a button.

    For example, how do you click a button that re-renders when the mouse hover over it? If you tried to click on the button that used to be there before, then you'll get a "stale element reference".

    How about a button that moves when the mouse goes over it?

    How about a button that is partially obscured by another element?

    How about a button nested in several scrollable containers?

    Unfortunately, these trick buttons are real scenarios I've seen in real business applications.

    In this presentation / live coding session, I'll show you some trick buttons, and how to hit them on the bullseye.

    UNTestable: It's Just Pressing a Button, How Hard Could it Be?

    Over the last 7 years, I've consulted several testing teams on test automation projects for their web applications, and the most frequent troubleshooting request I get is about clicking some button on some website.

    It's just pressing a button... how hard could it be... right?

    I came to discover there's many edge cases when it comes to simply executing a click on a button.

    For example, how do you click a button that re-renders when the mouse hover over it? If you tried to click on the button that used to be there before, then you'll get a "stale element reference".

    How about a button that moves when the mouse goes over it?

    How about a button that is partially obscured by another element?

    How about a button nested in several scrollable containers?

    Unfortunately, these trick buttons are real scenarios I've seen in real business applications.

    In this presentation / live coding session, I'll show you some trick buttons, and how to hit them on the bullseye.

    Outline/Structure

    • Self introduction
    • Live coding to solve different trick buttons with Selenium/Webdriver:
      • Trick button 1: "The clone" - Button that re-renders when mouse hover over it
      • Trick button 2: "The dodgeball" - Button that moves when mouse hover over it
      • Trick button 3: "The glass door" - Button that is partially obscured by another element (an unfortunately common issue)
      • Trick button 4: "The russian doll" - Button nested in several scrolling container

    Learning Outcome

    Learn how to automate clicking on elements for tricky but not uncommon edge cases.

    I thought about creating a subversive series on UNtestable UI elements, and this is a lesson on how to make UNtestable buttons.

    Target Audience

    Experienced test engineers

    Prerequisites for Attendees

    This session includes some live coding using Selenium / Webdriver and assumes that the audience is already familiar with Selenium / Webdriver syntax.

    Links

    I frequently write / talk about testing and debugging:

    I sometimes also write about software engineering in general:

Reserve Your Spot Now
register