location_city Online schedule Jul 29th 12:00 - 12:45 PM IST place Zoom people 113 Interested

The Web Authentication API (a.k.a WebAuthn) is a specification written by the W3C and FIDO Alliance. The API allows servers to register and authenticate users using public-key cryptography instead of passwords. This helps to strengthen the security posture by going password-less and enabling phishing protection. We can automate WebAuthn-based sites using Virtual Authenticators, and being W3C compliant, Selenium 4 makes it really easy (The Virtual Authentication feature in Selenium 4 is currently available only in Java and in a patch release of Python).

During the talk, we will explain what WebAuthn is and what virtual authenticators are with some quick demonstrations. Then, we will showcase how using Selenium 4 we can easily automate such cases. We are also going to cover the implementation in Selenium 3 (in case someone is still stuck with the old version :)

 
 

Outline/Structure of the Demonstration

  1. Introduction (2 min)
  2. What is WebAuthn (5 min)
  3. WebAuthn in Action (8 min)
  4. Authenticator Types (3 min)
  5. Virtual Authenticator in Action (6 min)
  6. WebAuthn Automation in Selenium 3 (6 min)
  7. WebAuthn Automation in Selenium 4 (7 min)
  8. Q&A (5 min)

Learning Outcome

  1. Gain an understanding of Web Authentication/WebAuthn (password-less authentication)
  2. Learn about Virtual Authenticators
  3. Get knowledge about WebAuthn automation using Selenium (using versions 4 and 3)

 

Target Audience

Developers, Testers, Engineering Managers, anyone interested to know more about password-less authentication

Prerequisites for Attendees

No specific pre-requisites. However, some basic understanding of Java/Selenium would be helpful.

Video


schedule Submitted 6 months ago

  • Maaret Pyhajarvi
    keyboard_arrow_down

    Maaret Pyhajarvi - Patterns to Whole-Team Test Automation Transformation

    Maaret Pyhajarvi
    Maaret Pyhajarvi
    Principal Test Engineer
    Vaisala
    schedule 6 months ago
    Sold Out!
    45 Mins
    Case Study
    Intermediate

    Looking back at test automation in a product development team for describing patterns of success for research purposes, we identified themes where the experienced success significantly differed from what the literature at large was describing. With those lessons, I moved to a new organization and took upon myself to facilitate a transformation to whole-team test automation over multiple teams, one at a time, one after the other. In this talk, we will revisit the research from one organization two years ago with lessons from another in the last two years. 

    In this talk, I will introduce you to my core patterns to practice-based test automation transformation. I can't promise a recipe I would apply, as my recipe changes and adapts as I work through teams, but I can promise experiences of the same patterns working on multiple occasions as well as examples of how my go-to patterns turned out inapplicable. We'll discuss moving from specialist language to generalist language, visualizing testing debt and coverage, using visualization to showcase progress made of continuous flow of small changes, choosing to release based on automation no matter how little test automation there is, and growing individual competencies by sharing YOUR screen when working together. 

  • Tariq King
    keyboard_arrow_down

    Tariq King - From Rigidity to Resiliency: An Evolutionary Tale of Selenium-Based Frameworks

    Tariq King
    Tariq King
    Chief Scientist
    test.ai
    schedule 5 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Prior to Selenium, engineering teams around the globe were struggling to build and maintain their own web testing solutions. Most frameworks at that time neither supported testing the front-end behavior of web applications, nor executing tests across different browsers and operating systems.  This forced teams to fill that gap with homegrown solutions and they were doing so in silos, without the support and backing of the open-source community or browser development companies. As we know, Selenium changed all of that and WebDriver has been a saving grace for development teams. However, the rise of Selenium unveiled a hidden set of web UI test automation challenges, many of which are still prevalent today.

    Join Tariq King as he takes you on a journey to address those challenges through an evolutionary tale of test automation framework development. Based on a true story, the tale starts with replacing a rigid homegrown solution with a more flexible internal Selenium-Based Domain Specific Language (DSL), and then extending that into an external DSL with powerful test management and software process integrations. The next step in the evolution incorporates AI-based element selection and self-healing features into Selenium. Curious about where the story goes or how it ends? Tariq will share his thoughts on the future of web UI test automation with Selenium.

  • Diego Molina
    Diego Molina
    Staff Software Engineer
    Sauce Labs
    schedule 5 months ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    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!

  • Manoj Kumar
    keyboard_arrow_down

    Manoj Kumar / Puja Chiman Jagani - Driving Observability with Selenium Grid 4

    480 Mins
    Workshop
    Intermediate

    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.

  • Srinivasan Sekar
    keyboard_arrow_down

    Srinivasan Sekar / Sai Krishna - Build your own Appium 2.0 Driver

    45 Mins
    Case Study
    Beginner

    What if you had to create a custom driver for your use case in your project and with Appium 1.0 it was not possible without making any code changes to the actual appium code base. This would lead us to maintain a fork and make our required changes. Which in turn is overkill as we have to always keep up with upstream. 

    With Appium 2.0 architecture we can create drivers and plugins for our unique needs. At this talk, we will talk about Appium 2.0 architecture, how to make custom Appium drivers and what other breaking changes we brought in Appium 2.0.

  • David Burns
    keyboard_arrow_down

    David Burns - Working in the Shadow (DOM) - How to test Web Components

    45 Mins
    Talk
    Beginner

    As Web Components gain more traction in the web to help websites become more performant it has created a bit of a blind spot on how to test these new features.

    In this talk, David will walk you through what Web Components are and how they are benefiting the web as we move forward. He will then walk you through how we can go about testing these and how, while well-meaning, other frameworks are making things a little harder to test. He will also go through some of the performance aspects of the Web Components and how this translates to your tests.

  • Puja Chiman Jagani
    keyboard_arrow_down

    Puja Chiman Jagani - Selenium has a new trick up its sleeve to track failures

    Puja Chiman Jagani
    Puja Chiman Jagani
    Team Lead
    Browserstack
    schedule 6 months ago
    Sold Out!
    45 Mins
    Talk
    Beginner

    As our systems and tests grow more and more complex we need to make sure that we have the tools to capture the root causes without spending hours or days chasing them down. This is where Observability becomes our best friend. Observability allows us to see what is going on inside a system based on what we think is crucial without trawling through logs! Just like any piece of software should be robust, scalable, maintainable, and reliable, it should also be observable. Observability makes the journey from identifying unexpected problems to identifying the root cause easier.

    To do so, the code should record as much useful granular information as possible. Metrics, logs, and traces are three known ways of encapsulating granular information. They are the primary sources of information to help determine the state of the system at any given point in time. 

    Selenium 4 introduced a fully distributed Grid with multiple components that communicate over the network. Troubleshooting and diagnosing problems in this setup is a challenge. To tackle this, Selenium integrated OpenTelemetry’s tracing and event logs.  This feature is now available out of the box by default when using Selenium.
    The users now have more power in their hands!

    I will dive into Selenium's observability journey by discussing: 

    1. What is observability?

    2. Need for observability

    3. Understanding the three pillars of observability: Metrics, Logging, and Tracing

    4. Generating telemetry data alone does not suffice. It is a process from design to deployment. 

    5. Full-stack tracing in Selenium (Grid and Java client library)

    6. Explain how we, at BrowserStack, are benefiting and exposing this information to our users.

  • Narmadha Ramasamy
    keyboard_arrow_down

    Narmadha Ramasamy / Sameena Syed - Functional Programming in Test Automation

    90 Mins
    Workshop
    Intermediate

    Functional programming(FP) exists from as long as object oriented programming. But most of the testing frameworks are written in OOPS style rather than FP. A typical automation tester knows little or nothing about it. Functional programming is a programming paradigm in which everything is written in terms of functions. This makes the code more modular, bug-free and parallelizable. Hence, it is important to first understand functional programming before avoiding it.

    In this workshop, we will introduce functional programming in testing world. We will help you understand some of the hard concepts of FP, like Currying, Higher order functions, and demonstrate how they can be used in writing an automation framework which is scalable and easier to maintain.

    We'll use Selenium 4.0 to automate a few UI scenarios, covering functional programming concepts and a code walkthrough to its object-oriented counterpart.  This will entice viewers to choose programming style based on its benefits rather than its simplicity.

  • Anton Angelov
    keyboard_arrow_down

    Anton Angelov - Become Black Ops QA with Selenium 4 BiDi-DevTools APIs

    Anton Angelov
    Anton Angelov
    CTO
    Automate The Planet
    schedule 6 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Anton Angelov will explain in many details and code examples how to automate hard-to-test web app functionalities using Selenium 4 BiDirectional and Chrome DevTools APIs. We will discuss test automation of progressive web applications, web sockets, memory leak checks. In addition, you will learn how to perform internationalization, localization, and network performance testing. Finally, we will investigate how you can use the protocols to speed up your tests using the black hole proxy pattern.

  • Eran Kinsbruner
    keyboard_arrow_down

    Eran Kinsbruner - Comparing Selenium 4, Cypress and Playwright Frameworks

    Eran Kinsbruner
    Eran Kinsbruner
    Global Evangelist
    Perfecto
    schedule 7 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    As the cross-browser testing landscape evolves, there is a stabilization around 3 main leading frameworks that are used the most. Some are more adopted by frontend developers, while some are adopted by SDETs. To better make a selection or even choose more than a single framework you need to realize the core differences and use cases as well as benefits each framework provides to the practitioner.

    In this session, Eran Kinsbruner, Chief DevOps evangelist, best-selling author from Perforce (Perfecto and Blazemeter specifically) will go through the core differences and advantages of all 3 frameworks with focus on Selenium 4 vs. the latest versions of Cypress and Playwright and provide a nice outline to better guide test automation engineers as they look for their next test framework.

  • Amuthan Sakthivel
    keyboard_arrow_down

    Amuthan Sakthivel - CLEAN TEST DESIGN PRACTICES FOR EFFECTIVE SELENIUM AUTOMATION FRAMEWORK

    Amuthan Sakthivel
    Amuthan Sakthivel
    SDET
    Clipboard Health
    schedule 6 months ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    Selenium is an amazing library for UI Automation. However, using it in a project needs a proper test design, a good approach and the best framework. I have listed some of the challenges that most people face during automation and will also brief on how we can solve those problems with effective design and approach.

    Key Challenges :

    1. Field level validations on a form containing several fields. (Many people will ignore these tests in automation as it may increase the number of lines of code and number of tests. Maintaining them is a difficult task)

    2. Verifying the state of the web element before operating on it. (It is imperative to check whether a web element is present or visible or clickable or needs a scroll to operate. Also, different elements need different explicit wait times. Most probably we will have number of methods like waitForElementToBeClickable, waitForElementToBeVisible. This again results in increased lines of code. )

    3. Assertion of multiple components on a page. (Sometimes we want to validate several items on a page and writing methods like getTitle, isCompanyLogoPresent, isFooterMenuPresent either results in multiple tests or poor test code spoiling the readability.)

    4. CI/CD integration. ( Most of the companies were using Jenkins as their CI/CD tool to schedule tests and this is most probably maintained by Devops team. To set up Jenkins job we need a lot of permission. At the worst we need a machine/infra to run and schedule our tests)


    How we can solve these commonly occurring problems?

    1. With the advent of functional programming, we can pass different behaviours to the test methods. In the demo, I will use BiPredicate Interface implementations to solve this problem with clean design.

    2. Annotations in Java is very powerful but hardly used in Test Automation Frameworks. I will use reflections and annotation to solve this problem with a much cleaner design.

    3. We can leverage Custom Validator classes and AssertJ to write some effective readable tests.

    4. We can leverage Github Actions and the Github runner to set up Selenium Grid Infrastructure and run our tests without any additional infra.

    Tech Stack : Java, Functional Interfaces, Selenium, AssertJ, Github Actions

  • Sidhartha Shukla
    keyboard_arrow_down

    Sidhartha Shukla - Continuous Testing With Selenium Automation

    Sidhartha Shukla
    Sidhartha Shukla
    SDET-II
    Amazon
    schedule 6 months ago
    Sold Out!
    20 Mins
    Talk
    Intermediate

    Continuous testing is the process of executing automated test cases as part of the software delivery pipeline to obtain immediate feedback on the business risks and add deployment blocker in Pipelines in case of any Error during test suite execution. “Continuous Testing allows any change made in the code to be tested immediately. This avoids the problems created by having “bigbang” testing left to the end of the cycle such as release delays and quality issues.

    Continuous testing is decisive for Full CI-CD in the project and to achieve it, we need to make our Automation very robust and impeccable.To implement continuous testing, we have to automate tests and create test suites(e.g. Regression, Smoke, Sanity, BVT, End to End, Functional). To design the automation suite, we will use the most stable automation framework (SELENIUM). Selenium allows the tests to be automated quickly, and execution is done as soon as a piece of code is ready at their respective stages of the release pipeline. So we will show in this topic that how quickly we can automate using selenium and it can be integrated into our our existing pipeline with ease. One point is preeminent to note that "Automation is the most integral part of continuous testing", and Selenium is the framework which helps us to achieve it.

    Continuous testing can be achieved using any CI-CD like Bamboo, CircleCI, Amazon CDK pipeline, and the best part is that Selenium can be integrated with all the CI-CD easily and efficiently. So just to give the audience a proper visualization of Continuous testing, we will use Jenkins as our CI-CD tool.


    Target Plan of Action :

    ==> Define Scope and Estimation.

    ==> Identify important features and scenarios, which will be part of Smoke/Sanity/BVT suite.

    ==> Develop Automation Framework with Selenium

    ==> Design test suite.

    ==> Automate Deployment process for both DEV/QA/UAT environment.

    ==> Create Jenkins job for automation suite by integrating pom.xml with Jenkins.

    ==> Create pipeline with deployment and automation jobs.

    ==> Integrate Email notification for Jenkins job execution status.

    ==> Add GIT web hook to auto trigger jobs with code push.

     

    Benefit Of Continous Testing:

    ==> We can add Deployment blocker in Pipelines in case of any Error during suite execution

    ==> More Test Reliability

    ==> Faster Release Rate

    ==> Reduce Costs

    ==> Easy Maintenance and Updates

    ==> Auto triggered jobs

    ==> Testing with more accuracy

    ==> Automated Email Notification for deployment and automation suite execution

    ==> Flawless and quick deployment

    Advance Plan of Action:

    ==> Automation regression suite with maximum coverage

    ==> Use script for job creation in Jenkins

    ==> Code quality with sonarqube integration

    ==> Slack notification for jenkins job execution report

    ==> Coverage report

    ==> Stabilize automation test scripts

  • Gaurav Patel
    keyboard_arrow_down

    Gaurav Patel - Test Automation Using UiPath

    Gaurav Patel
    Gaurav Patel
    Sr. Associate L2 QA
    1Rivet
    schedule 6 months ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    UiPath Test Suite is not just the solution for Software testing team to test their software applications but its also a solution for RPA team to help them to test their robotic Process Automation more effectively and efficiently. RPA developers can now create tests straight from their workflows, data-drive those tests and execute them leveraging UiPath Orchestrator. Test Suite help RPA teams reduce robot maintenance allowing them to focus on building new robots.

  • Chandrakanth Donagar
    keyboard_arrow_down

    Chandrakanth Donagar - Instant Selenium Cucumber Automation using AI

    Chandrakanth Donagar
    Chandrakanth Donagar
    Automation lead
    SAP
    schedule 6 months ago
    Sold Out!
    45 Mins
    Case Study
    Beginner

    Problem Statement:

    On usual procedure we need to write the step definition and data storage classes wrt PM model. For each of the feature steps we need to map that to relative stepdefinition i.e method which performs action.

    This eventually manual and time consuming effort.

     

     

    Solution is to automate cucumber test script generation using NLP technique. Tensor flow uses features files and converts the features files to required step definition methods(Java).Separate set of classes will be generated as per the application UI pages. Object repository will be created dynamically when user supplies the steps in feature file.

    Tool scans the html page and retrieves all required locators using intelligent locators generating strategy(to achieve this we need to supply strong data as part of feature files)

    This eventually leads to no code automation using cucumber with web driver.

help