filter_list help_outline
  • Liked Simon Stewart
    keyboard_arrow_down

    Simon Stewart - Selenium: State of the Union

    Simon Stewart
    Simon Stewart
    Project Lead
    The Selenium Project
    schedule 5 months ago
    Sold Out!
    45 Mins
    Keynote
    Intermediate

    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, reminiscing 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.

  • Liked Narayan Raman
    keyboard_arrow_down

    Narayan Raman - A Tale of Two Automation Tools

    45 Mins
    Keynote
    Intermediate

    Selenium and Sahi started as open source tools around the same time and from the same company. Both tried to solve the problem of UI automation and both have been successful in their own ways. But the resemblance ends there. Selenium became Webdriver and became one of the most popular free tools in testing. Sahi became commercial Sahi Pro and is successfully used in various organizations to automate complex UI's spanning web, desktop and mobile applications. Right from who the user of the tool is to whether the tool should be open source or commercial, there are various philosophical, technical and commercial junctures where Selenium and Sahi have diverged. Based on our journey of over 10 years, this talk reflects on those divergent decision points, the philosophy behind those and what their outcomes have been.

  • Liked Jim Evans
    keyboard_arrow_down

    Jim Evans - I'm Not Special.

    Jim Evans
    Jim Evans
    Contributor
    Selenium Project
    schedule 5 months ago
    Sold Out!
    45 Mins
    Keynote
    Advanced

    Since nearly the very beginning, the software industry has prized the concept of the visionary, the extraordinary creator, the lone person who relentlessly pursues their goal against impossible odds, all to help make the world a better place through technology. The industry also reveres the concept of dedication to the software above all else in the lives of those visionaries. Even those who have chosen to shepherd large portions of popular open-source projects are often seen as people who have a special quality about them that places them above other developers. These concepts are myths and oftentimes dangerous ones.

  • Liked Anne-Marie Charrett
    keyboard_arrow_down

    Anne-Marie Charrett - 2020 Vision:: Leadership

    45 Mins
    Keynote
    Intermediate

    It’s 2020 and a new decade awaits us. 100 years ago, our world was famous for the Russian Revolution and World War 1.

    In our century, we are also facing tremendous upheaval. The bushfires in Australia, floods in Indonesia. We are seeing the impact of climate change before our eyes.

    Technology-wise, agile has become mainstream. Hardware is cheap, CI and CD are commonplace. Robotics and Machine Learning is a reality. This is the age we live in. This is the now.

    How do we begin to plan for such a reality? How do we test software in such an ecosystem? Should we even try? How do we maintain skills, when frameworks change as rapidly as nail varnish on a teenager?

    As leaders in software testing, these are the questions we need to be able to answer. We need leadership now more than ever. We can’t predict the future, but we can prepare ourselves to be able to deal with change, to develop strategies that facilitate rapid learning and rapid change.

    We can upskill our people to be able to handle inconsistency and complexity. To know when technology is beneficial and when to rely on our ability to think critically.

    We must create environments where talent can grow and thrive. We learning (and failure) are embraced. Today is the day, we become the test leaders of the future. Are you with me?

  • Liked David Burns
    keyboard_arrow_down

    David Burns - Selenium: Giblets and all

    45 Mins
    Talk
    Beginner

    Selenium has done a pretty good job in keeping the API surface friendly and usable, but what actually happens when you call some of the commands? In this talk, David will walk you through what happens when you make a call in your test, how it gets to the browser, what happens in the browser, and how it returns all the way back to your test.

    Selenium is designed so that each of the commands works synchronously, so you know that a command has finished before it moves onto the next. This creates some interesting problems in browsers since they are mostly designed around asynchronicity.

    We will start with how each of the bindings communicates with the browser and then move on to how navigation works. David will show all the different aspects that we need to figure out to tell if a page is “loaded”. He will also show where it goes horribly wrong and how you can write code in your tests to stabilise around these “anomalies”.

    From there we will have a look at how clicks work from making sure they are trusted to what if they cause a navigation.

  • Liked Shweta Sharma
    keyboard_arrow_down

    Shweta Sharma / Nikita Jain - Accessibility testing 101

    45 Mins
    Talk
    Beginner

    "This world is such a beautiful place to live in." If you can read the first sentence without any screen readers or assistance, you're privileged. As technologists, shouldn’t we be more empathetic towards differently-abled people and make all parts of our website accessible to them? In my humble opinion, the true power of technology can be identified when it reaches out to people of all kinds having different physical or psychological challenges. We not only legally bound to provide Accessibility but also it should be considered as our moral responsibility.

    As testers, we have a wonderful opportunity to contribute to Accessibility by ensuring that the site is accessible in many different ways. Although it is impossible to identify all the issues that exist around Accessibility in the world, we are lucky enough to still understand a majority of them. With this understanding, there have been many measures taken in order to make your site accessible. But, don’t forget - we are QA engineers. We got to ensure that the site is accessible as per the standards set by WCAG 2.0 (AA) by testing for accessibility using various tools and techniques.

  • Liked Tarun Maini
    keyboard_arrow_down

    Tarun Maini - LifeCycle of Testing AI/ML Applications

    Tarun Maini
    Tarun Maini
    Senior Quality Analyst
    ThoughtWorks
    schedule 7 months ago
    Sold Out!
    90 Mins
    Workshop
    Intermediate

    With the seismic shift in industry and development of new technologies emerging, QA’s testing approaches are also changing, we must know the right strategies and algorithms to test. One of the latest technology emerging is Artificial Intelligence and Machine Learning. And its applications like Self driving cars, Virtual Assistants are everywhere. They have great impact in our life and most of our decisions, behaviour & destinations depend on them.

    So in this presentation/Workshop i would like to present all the ways/strategies/ challenges faced while testing AI/ML applications. Join me in creating a Machine Learning application from scratch and then take it to testing stage, creating edge case scenarios and validations.

    Time Management: To make sure that all people are upto date with with setup for hands-on, i will be sharing this document with the participants 12 days before in a temp slack channel, where they can share the progress and ask queries to resolve them quickly.
    *No internet is required for participants if they follow the setup doc.

  • Liked Boni García
    keyboard_arrow_down

    Boni García - Developing Selenium tests with JUnit 5

    90 Mins
    Workshop
    Intermediate

    Selenium has become the de-facto standard framework for end-to-end web testing nowadays. JUnit 5 is the latest version of this popular testing framework and implements a brand-new programming and extension model named Jupiter. This talk presents Selenium-Jupiter (https://bonigarcia.github.io/selenium-jupiter/), an open-source JUnit 5 extension aimed to provide seamless integration with Selenium. At first glance, it allows to create Selenium tests using local or remote browsers, reducing the required boilerplate thanks to the dependency injection mechanism supported in JUnit 5. Moreover, it will enable us to use different types of web browsers and Android devices in Docker containers out of the box. All in all, Selenium-Jupiter can be used to carry out different types of tests for web and mobile applications, including functional, compatibility (using test templates to define different devices or browsers -types and versions-) or performance (using a significant number of browsers through Kubernetes) tests.

    Moreover, Selenium-Jupiter provides advance capabilities for diagnostics, i.e., finding the root cause of a failed Selenium test. The first one is screenshotting. When a failure is detected, the state of the browser just before the failure happens can provide the clue to determine the nature of the problem. If the screenshot is not enough, the next step is to watch the browser during the test to observe the evolution of the web under test. This process is straightforward when running a test with the local browser, but it can be tricky in the usual case of running a test in a headless environment, such as Jenkins or Travis to name a few. In Selenium-Jupiter, this is done very smoothly thanks to the use of web browsers and Android mobile devices in Docker containers, in which the GUI session is recorded using VNC and FFmpeg. The last mechanism proposed is the access to browser logs to debug the JavaScript traces of our applications. Unfortunately, the Selenium API only allows us to do it when Chrome is used as a browser. The solution proposed is to use monkey patching in the console object at JavaScript level in a cross-platform browser extension, which is used to instrumentalize the browser (e.g., Firefox, Opera) controlled with Selenium WebDriver. To ease the access to such information, Selenium-Jupiter provides seamless integration with Jenkins and Slack, publishing the resulting files (PNG screenshots, MP4 recordings, and TXT logs) in the Jenkins GUI or Slack channel when a test fails.

  • 45 Mins
    Talk
    Intermediate

    In this era of Digital transformation, clients have been demanding shorter and quicker releases. Shorter and quicker releases mean your team should not only be able to develop them at the required pace but also test and release them at a sustainable pace. User interface plays an important role in the client's business and there are organizations that release new features, fancy CSS regularly that support multiple browsers, multiple Operating systems, mobile devices. Verifying the frontend on this browser/device/OS matrix by humans is not only extremely time consuming but also prone to human errors. In fact, testing by humans should primarily focus on discovery leaving the repetitive and error-prone tasks to tools. Hence, automating Visual tests is becoming less of an optional activity and more of a must-have activity within the team. Ensuring visually perfect user experiences is equally important as to have the functionality working.

  • Liked Abhijeet Vaikar
    keyboard_arrow_down

    Abhijeet Vaikar - End-end test code as a first class citizen

    45 Mins
    Case Study
    Intermediate

    "All tests in today's automated regression run have been marked as Untested. What happened?"

    "No notifications are being sent for test runs on the channel"

    "I pulled latest code, and the framework dependency shows compilation error"

    "What does this new method in the framework do?"

    How often do you hear such things within your team?

    As Quality champions, we need to walk the talk. When we expect our developers to write quality code, write unit tests, build features without introducing bugs, the onus lies on us (as test engineers) to do the same. With almost every test engineering team writing automated tests to check functionality of their products and services, it becomes very important to ensure that the test automation framework and the test scripts are bug-free and follow good standards of software engineering.

    It cannot be stressed enough that test automation code should be as good as production code. In order to build production-quality test automation framework and scripts, a number of steps can be taken at:

    1. Code & System Level

    2. Process & People Level

    Our test engineering team went through a transition from having random & unexpected failing test runs to having greater confidence in the quality of the tests. Learn from this case study of our journey to ensure that end-end UI automated tests are built with quality in mind. We will also see demonstration of some of the use cases.

  • Liked Tarun Narula
    keyboard_arrow_down

    Tarun Narula / sandeep yadav - What to do when tests fail

    45 Mins
    Talk
    Beginner

    What to do when your tests fail? Read on...

    Functional automation is known to be flaky. A test passes sometimes & fail the other times. The failure can be attributed to multiple factors. We need to find out the root cause & then work towards fixing it for increasing automation tests reliability.

    In this talk, we will not only be discussing causes that lead to a test failure, but we will also talk about prevention, early detection & fixing these failures for good.

    We will discuss some common test failure causes such as locator changes, browser compatibility issues, coding bloopers etc

    You will get to know how you can get alerted early about any test failures. We will be discussing topics such as running tests on under development builds for getting early feedback, triggering slack/SMS/email notifications with failure details for immediate redressal and many others.

    You will get to know how to prevent failures by building robust locators, exception handling, making use of APIs for test data setup, building atomic tests, making use of waits, retrying your failed tests, rebuilding your Jenkins jobs automatically based upon a failure percentage threshold & so on.

    At the end of this talk, you will be confident on how to deal with your failing tests!!

  • Liked Gopinath Jayakumar
    keyboard_arrow_down

    Gopinath Jayakumar / Babu Narayanan Manickam - Expanding boundaries of WebDriver with DevTools Integration

    45 Mins
    Demonstration
    Beginner

    Problem Statement

    Though Selenium taking most of the stake in the UI test automation tool market comfortably, there were always challenges that were for selenium test automation engineers are handicapped with especially when dealing with modern JS technologies. For example,

    • dealing with DOM elements to solve the stale / loading / non-interactable elements,
    • handling full screenshots to know how the elements at the left, bottom, etc,
    • measuring the performance of request and response resources at different speeds,
    • monitoring the memory of the pages, controls, etc,
    • attaching to an existing browser for debugging the failed scripts and many more.

    These problems were largely resolved with the integration of selenium with devtool protocols. And that makes the selenium engineer's life merrier than before.

    Why this proposal can be different from others?

    1. Our solution can be executed as independent with chrome dev tools or with selenium. That gives the power back to the automation engineer to choose what and how to debug/run their tests.
    2. We used this solution for one of our largest enterprise customers and moved this solution to public repository this week (for this conference and beyond). With that said, we tested reasonably with more than 10,000+ test scripts and more than 1M tests.
    3. The present solution is completely (100%) packed with all Chrome Dev Tools API in Java and with that said, any Java Selenium automation engineer can bind in minutes for their existing code base with no additional dependencies.
    4. Finally, we love to present at the local home to start our selenium conference campaign. Where else?

    Solution:

    The present proposal largely connected with Chrome and Selenium in Java language. However, there is no limitation to expand the boundaries for other language bindings and browsers.

    Google Chrome, the most picked browser for browsing, which makes it the primary concentration for developers and testers. DevTools is one such boon for developers, testers especially the new aged test automation engineers. With that said, we built the following design pattern to allow chrome dev tools API to marry Selenium using debugger address / remote targets.

    Selenium Devtools

  • Liked Rajdeep varma
    keyboard_arrow_down

    Rajdeep varma - The Joy Of Green Builds - Running Tests Smartly

    45 Mins
    Talk
    Intermediate

    So you have got a few UI tests and they are running in parallel, great! However, life will not be so sweet once these 'a few' turns into 'a lot'. We grew from a few to 1500 UI tests (although not particularly proud of this number, there are situations and reasons)

    We started with a simple parallel distribution of tests 3 years ago. As test count increased failure count run time increased along with increased flaky tests. Mobile tests had their own challenges (eg. device dropping-off, random wi-fi issues, etc) To keep up with this, we created a queue and workers based solution which could distribute the tests more efficiently (https://github.com/badoo/parallel_cucumber). Over time, we made more improvements, in particular:

    • Segregation of failures based on infrastructure issues and re-queue the tests
    • If a device/emulator malfunction, rescue the tests to another device
    • Repeating a single test on 100s of the worker in parallel to detect flakiness
    • Repeat a test if a known network issue
    • Terminating the build early if more than a certain number of tests have failed
    • Health check of each device, before each test to ensure reliability
    • Muting a test if failure is known, and highlight outdated mutes if the related task is fixed

    In this talk, I will talk about the initial challenges with running UI tests in parallel (Selenium and Appium), how we approached the queue based solution and continuous improvement of this solution; finally, how attendees can use it at their workplace or create their own solution based on our learnings.

  • Liked Virender Singh
    keyboard_arrow_down

    Virender Singh - Rise of Shadow DOM - Lets solve it through WebDriver

    45 Mins
    Demonstration
    Beginner

    Shadow DOM is kind of web standard that developers use to encapsulate their custom HTML code and style components so that no other global style components can override their code. It ensures that a component will work in any environment, even if other CSS or JavaScript is run on the page i.e. Shadow DOM hides away the complexity of the components from the rest of the page because it renders separately from main DOM.

    Selenium legacy selectors are not able to interact these custom elements under the shadow DOM so we need java script to interact with shadow DOM elements and we also require JavascriptExecutor interface for their execution.

    We will also talk about the WebdriverIO tool v5.5.0, which implicitly support Shadow DOM elements.

     
     
  • Liked Ivan Krutov
    keyboard_arrow_down

    Ivan Krutov - Master-class: Bulletproof Selenium cluster

    Ivan Krutov
    Ivan Krutov
    Developer
    Aerokube
    schedule 7 months ago
    Sold Out!
    45 Mins
    Demonstration
    Beginner

    Browser tests are known to be the flakiest ones. This is partly because browser infrastructure is complicated to maintain. But the second reason is – mainstream browser automation tools such as Selenium server are far from being efficient.

    During my previous talks I was speaking about Selenoid - a truly efficient replacement of the standard Selenium server. This year I would like to do a live demonstration how to organize a fault-tolerant and easily scalable Selenium cluster using virtual machines in the cloud. I will start by setting up Selenoid and show its powerful features like video recording, live tests debugging, manual testing and many more. Then I will configure Selenoid to send logs and recorded videos to S3-compatible storage. Finally we will run a Ggr load balancer instance allowing to use all running Selenoid nodes and organize a single entry point to the cluster.

  • Liked Zbyszek Mockun
    keyboard_arrow_down

    Zbyszek Mockun - Automation in the world of projects

    45 Mins
    Case Study
    Intermediate

    The world of a software house is a constant search for compromise between quality and costs. In many cases, the cost-cutting starts from the test automation. Then you start to talk about ROI but recognize that numbers are not on your side. We were there and what we have found out is that only a complete change in our approach allows us to find common ground with our clients. I will reveal one detail from the presentation - we are not talking about test automation with clients anymore - as a result we do it more and more.​

    Are you surprised that success automatically generates new challenges which we further translate into opportunities? We had to reconsider our approach to the test automation environment, internal frameworks and the way we share them between projects, including code ownership, … And again, one simple but unobvious solution allows us to both deliver what we promise and to earn more on our projects.​

    As we have been reshaping our approach to the test automation, we had to change the way of delivery too. One of the main decisions was skip out the role of test automation engineer (or software developer in test). We decided to go with the whole team approach which is consistent with the way we sell it. ​

    Find it interesting? Join me and listen to our story about how we have transformed test automation.

  • Liked rajni singh
    keyboard_arrow_down

    rajni singh - End to end testing strategies for intelligently connected hybrid world of IoT

    rajni singh
    rajni singh
    Senior Manager
    Nagarro
    schedule 7 months ago
    Sold Out!
    45 Mins
    Tutorial
    Intermediate

    The intelligent mesh of devices is nothing but connecting millions of users, use cases, apps, and devices together to support application developed based on the internet of things. Currently, we see around the world that there are thousands of use cases, millions of apps, billions of users and trillions of things and if you think QA and testing in the interconnected intelligent devices then the scope would be very wide as verification and validation will be applicable in each interface and as and when grows.
    I will talk about the challenges faced during IoT application testing and how it can go wrong. To thorough test all the area with the given challenges and IoT test lab is setup. What all are the solution to overcome the challenges. Some important aspects like continuous integration of hybrid environment and testing with multiple devices and with millions of use cases, to improve the existing conventional method with intelligent automation, and most important is scalability and security.

    Although testing emerging technology and applications always is exciting, seeing their own strategies and tools fail in IoT testing can be frustrating even for well-seasoned testers. I aim to provide testers with a better understanding of connected systems like smart cities, connected enterprise and help them to apply their critical thinking to deal with uncertainty in their test objects.

  • Liked Rabimba Karanjai
    keyboard_arrow_down

    Rabimba Karanjai - Testing Web Mixed Reality Applications: What you need to know for VR and AR

    Rabimba Karanjai
    Rabimba Karanjai
    Researcher
    Mozilla
    schedule 7 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    There are already over 200 million users consuming VR applications by 2018. And with Google, Mozilla pushing WebXR capabilities in browser and vendors like BBC, Amnesty International, Universal, Disney, Lenskart and a lot of them adopting them to their websites, we will soon see a huge rise i demand for Web VR and Mixed Reality applications.

    But how do you test them in scale? How do you define "smooth" as opposed to just responsive?

    In this talk I will go over some key details about the WebXR specification. The work that Mozilla, Google and the W3C Immersive Web Group is doing. The differences between testing a regular web page and a Mixed Reality enabled one. What to watch for and how you can automate it.

  • Liked Krishnan Mahadevan
    keyboard_arrow_down

    Krishnan Mahadevan - My experiments with Grid

    45 Mins
    Tutorial
    Intermediate

    Everyone starts off with a simple grid setup which involves a hub and one or more nodes.

    This traditional setup is a good start but the moment one starts to get serious with the selenium grid and decide to house their own selenium grid for their local executions, that is when issues start.

    My experiences with the Selenium grid in the past couple of years has led me to get introduced some of the most prevalent problems with maintaining an in-house selenium grid.

    • Nodes get unhooked randomly due to network glitches.
    • Nodes introduce false failures due to memory leaks.
    • Selenium Grid running out of capacity.
    • Nodes require OS upgrades/patches etc.
    • Needing to deal with auto upgrades by browsers (especially chrome and firefox)

    Some of these issues I managed to fix by building a "Self Healing" Grid wherein the nodes automatically get restarted after they have serviced "n" tests. But that still didn’t solve many of these other problems.

    That was when I felt, what if there was an on-demand selenium grid.

    What if the Grid could do the following ?

    • The Grid auto scales itself in terms of the nodes based on the current load.
    • The Grid does not require a lot of infrastructure to support it.
    • The Grid can plug itself into some of the cloud providers or leverage a solution such as Docker so that the nodes can be spun and shutdown at will.

    That was how the idea of "Just Ask" an on-demand grid was born.

    Just-Ask is an on-demand grid. It has no nodes attached to it.

    It’s designed to spin off nodes on demand, run test against the newly spun off node and after test runs to completion, clean-up the node as well. The node can be backed by anything. It could be Docker (or) it could be a VM running on any of the popular clouds.

    The session aspires to walk the audience through with my experiments with the selenium grid, my learnings on the selenium grid internals and how I used all of that knowledge to build my own On Demand Selenium Grid. What better avenue to share these learnings than a Selenium Conference.

    The session will introduce the audience to the grid internals and their concepts such as

    • What is a Selenium Remote Proxy ? What is it used for? What can you do with it?
    • What is a Hub (or) Node level Servlet ? When would you need one ?
    • All of this followed by a quick demo on "Just Ask", the on-demand grid that I have built and open sourced here: https://github.com/rationaleEmotions/just-ask

  • Liked Gaurav Singh
    keyboard_arrow_down

    Gaurav Singh - How to build an automation framework with selenium : patterns and practices

    Gaurav Singh
    Gaurav Singh
    Product Engineer
    Go-Jek
    schedule 8 months ago
    Sold Out!
    45 Mins
    Talk
    Beginner

    With an ever increasing no of businesses being conducted on web the testing need to write automated tests for the app's UI is something that can never be ignored. As you all know Selenium provides an API that enables us to do this quite effectively.

    However, when tasked with setting up the automation framework, there are a lot of questions that arise in the minds of aspiring test developers regardless of what level they are in their career.


    Some of such questions are:

    1. How does one actually go about the business of building a robust and effective automation framework on top of selenium?
    2. What are the elementary building blocks to include in the framework that an aspiring automation developer should know of?
    3. How should we model our tests? XUnit style vs BDD?
    4. Are there good practices, sensible design patterns and abstractions that we can follow in our code?
    5. What are some of the anti patterns/common mistakes we should avoid

    A lot of literature, documentation and blogs exists on these topics on the web already.

    However In this talk,

    I would combine this existing knowledge and my years of experience in building automation frameworks and breakdown these elements and walk you through exactly the sort of decisions/considerations and practices that you can take while starting to implement or improve the UI automation for your team.

    Hope to see you there!