TestComplete supports Selenium – Other Commercial tools will follow soon?

Oliver Wendell Holmes once said: I would not give a fig for the simplicity this side of complexity, but I would give my life for the simplicity on the other side of complexity.

Tool evangelists around the world have been using this phrase for selling their products. They make it a point to look into customer’s eyes and say “Scalability, you know, that’s the main problem with Selenium. What about 3 years down the line, when you have multiple applications in your landscape and Selenium does not support it?”

But they simply ignore the fact, knowingly off course, that this ever belting technology world is going where Selenium is right now. Applications are shrinking into browser windows and changing tracks to align itself to this mobile era.

Even commercial tool like TestComplete from SmartBear has started supporting Selenium and many will follow soon. Reason for this change is not only that most of the organizations are preferring open source tools like Selenium for starting point of their automation activities but also the fact that Selenium by far has proven itself to be one of the best automation tools when it comes to mobile or browser based desktop automation.

Here our aim is to display how seamlessly Selenium integrates with TestComplete and QAComplete and it is for us to understand that it is not Selenium which needs other tools to extend it but it is the other way round.

 
8 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

1. What tool evangelists generally say?

2. Are commercial tools ready to incorporate Selenium into it?

3. How easy it is to incorporate existing Selenium assets into TestComplete?

4. A glance at commercial Test Management tools supporting Selenium

5. Lets be Harbinger, Lets start with Selenium!!!

Q & A

Learning Outcome

What compels an automation product company to support an open source tool? It’s the sheer fact that Selenium has prevailed as one of the widely used tool for automation and is seen as primary choice of web automation in coming future. So it’s natural for Commercial tools to provide support and extend selenium for their own survival. So given the trends, if one wants to start automation with Selenium, should not think twice since as application landscape grows, number of tools supporting Selenium will also grow.

Target Audience

Test Analysts

schedule Submitted 2 years ago

Comments Subscribe to Comments

comment Comment on this Proposal

    • Liked Oren Rubin
      keyboard_arrow_down

      Oren Rubin - Why Building Record/Playback Tools Is So Hard

      Oren Rubin
      Oren Rubin
      Founder and CEO of Testim
      Testim.io
      schedule 2 years ago
      Sold Out!
      45 mins
      Talk
      Beginner

      Almost every manual QA started with Selenium IDE or at least tried it at some point.. retention rate is close to 0.

      In this talk we will depict the challenges that Test Automation Developers face. We'll categorise the challenges, name them, and see the skillset required to overcome the difficulties.

      We'll compare the different Record/Playback tools and see where they excel, and where we must resort to traditional solutions (e.g. generic programming languages, and the Page Object design).

      This talk will discuss topics such as Reuse of code, Component Isolation, Separation of Concerns, APIs, where test fragility stem from and how to overcome it, etc..

    • Liked Jonathan Lipps
      keyboard_arrow_down

      Jonathan Lipps - The Mobile JSON Wire Protocol

      45 mins
      Talk
      Intermediate

      The JSON Wire Protocol (JSONWP) is the version of the WebDriver spec currently implemented by all the Selenium clients. It defines an HTTP API that models the basic objects of web automation---sessions, elements, etc... The JSON Wire Protocol is the magic that powers Selenium's client/server architecture, enables services like Selenium Grid or Sauce Labs to work, and gives you the ability to write your test scripts in any language.

      The JSONWP has served Selenium faithfully for a number of years, but the future of automated testing lies beyond the borders of the web browser. Mobile automation is an essential ingredient in any build, and tools like Appium or Selendroid have made it possible to run tests against mobile apps using the JSONWP. The JSONWP's current incarnation isn't enough to automate all the new behaviors that mobile apps support, however. Complex gestures, multiple device orientations, airplane mode, and the ability to use both native and web contexts, for example, are all essential to mobile automation.

      For this reason the leaders of the Selenium project, in concert with other Selenium-based projects like Appium and Selendroid, met to discuss the future of the JSONWP. We've been working on its next version, called the "Mobile JSON Wire Protocol" (MJSONWP). Appium and Selendroid already implement much of the MJSONWP spec. In this talk I'll dive into the specifics of the MJSONWP extensions, how they relate to the original JSONWP, and how the Selenium clients have begun to implement them.

      Finally, I will talk about the future of the MJSONWP and how it's related to the current and future versions of the WebDriver spec. I'll share how you can get help with the creation of the MJSONWP, and discuss issues with the authors of the new spec before the API is set in stone. We need the help of everyone who's involved in mobile automation to come up with the best and most future-proof version of the MJSONWP. Ultimately, your understanding of how Selenium works will be improved, and you'll have a much better handle on how projects like Appium and Selenium work together to make sure you have the best automation methods available.

    • Liked Ragavan Ambighananthan
      keyboard_arrow_down

      Ragavan Ambighananthan - Distributed Automation Using Selenium Grid / AWS / Autoscaling

      45 mins
      Talk
      Advanced

      Speed of UI automation has always been an issue when it comes to Continuous Integration / Continuous Delivery. If UI automation suite takes 3 hours to complete, then any commit happens during this time will not be visible in test environment, because the next deployment will happen only after 3 hours. 

      With 2000+ developers and average 250+ checkins per day, the above issues is replicated 250+ times every day. This is not productive and feedback cycle is super slow!

      Another issue is , with 35+ different project teams using 10 or more different jenkins jobs to run their UI automation. So many jobs means (350+), individual teams need to go through the pain of managing their own jenkins job, its a duplicate effort and waste of time. Automation teams need to spend time on writing reliable automation and not managing jenkins jobs.

      Solution is to reduce the UI automation run time from hours to minutes and also use only handful of jobs to run the Distributed Automation!

      Goal: To run all UI automation scenarios within the time take by the longest test case

    • Liked rajesh sarangapani
      keyboard_arrow_down

      rajesh sarangapani - Visualizing Real User Experience Using Integrated Open Source Stack (Selenium + Jmeter + Appium + Visualization tools)

      45 mins
      Demonstration
      Advanced

      Traditional approach in performance testing does not include client side processing time (i.e. DOM Content Load, Page Render, JavaScript Execution, etc.) as part of response times, performance tests has always been conducted to stress the server so tools like Jmeter have been very popular to execute tests. With increasing complexity of architectures (Web, Browser, Mobile) on the client side it has been important to understand the real user experience.   Commercial tools have started to provide features that can provide insights into real user experience after the bytes are transferred to the client end.  With the ability to call Selenium scripts via Jmeter the ability to conduct real user experience tests using open source stack has opened up new avenues to comment on real user experience.   This enables us to comment on

      • Provides Page load times similar to On Load time of real browsers
      • Generates HAR file with following statistics
      • Details of summary of request times and content types
      • Waterfall chart with page download time breakdown statistics such as  DNS resolution time, Connection time, SSL handshaking time, Request send time, wait time and receive time.

      By integrating the open source stack tools it enables us to provide the same insights which a commercial of the shelf tools would offer.   At Gallop we have implemented this at multiple clients providing them insights into various bottlenecks at the client side which helped us to provide greater value proposition

    • Liked giri
      keyboard_arrow_down

      giri - Big Data - Verify Data Completeness and Data Correctness using Selenium/JAVA

      giri
      giri
      Director
      Gallop Solutions
      schedule 2 years ago
      Sold Out!
      45 mins
      Talk
      Beginner

      Using Hadoop MapReduce, Java programs are written to process large amounts of Data. Testing has to be performed to check the accurate functioning of these applications. Testing process includes manually verifying business logic on each node for MapReduce process accuracy, Data aggregation/Segregation rules and Generation of Key Value pairs. At the same time, Output data files are also verified for Transformation Rules, Successful Load, Data Integrity and Data Accuracy.

      Due to the enormous amount of data and various business rules, manual testing process is time consuming and may lead to slippage of validations. Implementing the automation testing process using Selenium & Java Adapters will make sure the data is complied with all the business/transformation rules and checks the data integrity.

    • Liked Trinath Babu
      keyboard_arrow_down

      Trinath Babu - Visual Test Automation using Selenium

      Trinath Babu
      Trinath Babu
      Sr. Manager
      Gallop Solutions
      schedule 2 years ago
      Sold Out!
      45 mins
      Talk
      Intermediate

      Visual Test Automation using Selenium

      Visual Testing is the method of verifying that the application’s GUI appears correctly to its users. Most of the people say visual testing is hard to automate. Given the number of web browsers, operating systems, screen resolutions, responsive design, internationalization, etc.) the nature of visual testing can be complex. But with existing open source and commercial solutions, this complexity is manageable, making it easier to automate than it once was, since verification with traditional automated functional testing tools can be very challenging.

      It can be easily achieved by integrating Selenium with Applitools. This talk mainly focuses on verifying the application’s graphical user interfaces (GUI) and finding the visual bugs using Applitools. It is very helpful for all sites having graphical functionalities like (charts, graph, dashboards etc).  Verify that the GUI appears correctly across all devices & browsers. The nature of visual testing can be complex. But with existing open source and commercial solutions, this complexity is manageable, making it easier to automate than it once was. And the payoff is well worth the effort.

      Take pressure off manual QA: increase coverage, test faster & more accurately.  Reduce maintenance efforts: automatically propagate changes across execution environments. Release faster, with confidence & flawless.

      Applitools Eyes Express captures the screen you want to test, and compares it to a baseline image – instantly, with a single click. No extra testing code necessary, no boring error logs.

      For example, a single automated visual test will look at a page and assert that every element on it has rendered correctly. Effectively checking hundreds of things and telling you if any of them are out of place. This will occur every time the test is run, and it can be scaled to each browser, operating system, and screen resolution you care about.

      Put another way, one automated visual test is worth hundreds of assertions. And if done in the service of an iterative development workflow, then you’re one giant leap closer.

       

      Each of these tools follows some variation of the following work flow:

      1. Drive the application under test (AUT) and take a screenshot
      2. Compare the screenshot with an initial “baseline” image
      3. Report the differences
      4. Update the baseline as needed
    • Liked Oren Rubin
      keyboard_arrow_down

      Oren Rubin - Selenium Wat!

      Oren Rubin
      Oren Rubin
      Founder and CEO of Testim
      Testim.io
      schedule 2 years ago
      Sold Out!
      45 mins
      Case Study
      Intermediate

      Every language and framework which lives as long as Selenium has its fuckups.. and we're here to embrance them and joke about them.

      E.g. JS Wat https://www.youtube.com/watch?v=FqhZZNUyVFM

    • Liked Tanay Nagjee
      keyboard_arrow_down

      Tanay Nagjee - Run your Selenium tests in a fraction of the time

      45 mins
      Talk
      Intermediate

      Comprehensive functional testing is a widely accepted best practice and Selenium is the prevalent tool of choice. But long-running Selenium test suites cannot be fit into short continuous integration (CI) cycles and are often run once a night or less. Running functional tests less frequently means bugs are discovered later than they should. Tanay Nagjee will discuss how Selenium test suites can be parallelized at a very fine granularity and included in CI builds. By leveraging a cluster of compute horsepower (on-premise and/or cloud), large Selenium suites can execute in a fraction of the time by smartly parallelizing the individual tests and running them on individual *cores* (not hosts). Tanay will outline the approach and tools to achieve these results with Selenium, and will present a live demonstration.


    • Liked Vishal Aggarwal
      keyboard_arrow_down

      Vishal Aggarwal - Selenium Next Generation Framework

      Vishal Aggarwal
      Vishal Aggarwal
      Test Architect
      Gallop Solutions
      schedule 2 years ago
      Sold Out!
      45 mins
      Talk
      Beginner

      This talk focuses on the technical side of automated acceptance tests for web applications. There are a lot of high-level frameworks that allow definition of acceptance tests in natural language (Robot, JBehave, Cucumber etc). But when it comes to the technical implementation of the test cases, you are often forced to use the rather low-level WebDriver API directly.

      GEB addresses exactly this problem. It is an abstraction of the WebDriver API and combines the expressive and concise Groovy language with a jQuery-like selection and traversal API. This makes the test implementation easier and the code more readable. On top of that, we get support for the page object pattern, asynchronous content lookup and a very good integration in existing test frameworks which makes it simply next generation of automation framework.

    • Liked vishnu nallani chekravarthula
      keyboard_arrow_down

      vishnu nallani chekravarthula - Extending Selenium Element Locator Strategies – Element Filtering

      45 mins
      Talk
      Intermediate

      Element Locator strategies for Selenium WebDriver are highly flexible, and have been later inherited by many commercial tools. Although the locator strategies are flexible, they are also limited in a sense that, Selenium WebDriver does not currently allow its users to identify/filter UI elements with multiple locator strategies(at a time), as many commercial tools do.

      The solution discussed in this article describes a library that allows Selenium WebDriver users to extend the Selenium element locator strategies for Element Filtering and few use cases for the library.

      The solution approach allows users to continue to use the existing UI Element definitions in their tests, and extend them, using the By reference. The library will replace the existing Selenium WebDriver “By” reference.

      Filtering based on multiple locator strategies

      There are various scenarios where to uniquely identify an UI element, a complex XPath has to be written. However, the element can be identified uniquely using multiple locator strategies for the UI Element. The UI Elements can also be filtered, when there are multiple matches in a page. This is the UI Element recognition mechanism used in many commercial test automation tools.

      The algorithm for filtering UI Elements based on multiple locator strategies is based on priority of locator strategies. The priority of locator strategies when filtering is:

      1. ID
      2. Name
      3. TagName
      4. ClassName
      5. XPATH
      6. LinkText and PartialLinkText
      7. CSS

      The By.elementFilter method takes multiple locator strategies, and searches the page for elements matching a particular locator strategy/property, and checks if it is a unique match on the page, if not then it uses the next locator strategy passed to it and so on.

      This method is also very helpful when the application undergoes constant changes and UI Elements might have either of XPATH, ID , NAME, TagName, ClassName etc still unchanged. That way, it helps reduce a lot of maintenance effort in Selenium WebDriver implementations which is due to UI element changes.

      Filtering based on Index

      When there are multiple similar UI Elements in a page, such as cells in a grid/table, it makes sense to identify objects based on their Index based on their appearance on the web page.

      The By.indexFilter method allows users to define an UI Element based on its Index of occurrence of the UI Element. The Index starts from 1.

      Filtering based on relative element

      When a UI element cannot be identified uniquely and reliably by any of its properties, but has some elements in its hierarchy or relative to a particular element, this method can be used to identify the element

      The By.relationFilter method allows users to define an UI Element in relation to another element. The relation can be defined as “Left”, ”Right”, ”Top”, ”Bottom”, ”Child”, ”Parent”

      Filtering for Tables

      When dealing specifically with Tables, which have the

      html tag, the By.tableFilter method allows the user to quickly identify specific cells in the table, without having to write complex XPaths or logics to achieve the same.

      The By.tableFilter method allows users to define a cell in the table with Row,Column numbers. This allows users to directly use the UI Element in their code instead of writing their logic each time. This also increases efficiency and readability of the code.

    • Liked Dipesh Bhatewara
      keyboard_arrow_down

      Dipesh Bhatewara - UI Automation As A Web Service

      Dipesh Bhatewara
      Dipesh Bhatewara
      Staff Engineer
      VMware Software
      schedule 2 years ago
      Sold Out!
      45 mins
      Talk
      Intermediate

      In modern cloud aeon, customers are delivered with UI and API for most of the Enterprise Products. The QE teams have to test the product for UI and APIs from functional as well as non functional perspective. For these they typically end up writing different test suites.

      There are lot of challenges one faces when automating test suites for these different purposes, like

      1. How do you integrate UI automation seamlessly with different test frameworks/suites?
      2. How do you test all these requirements (UI, API, Performance etc.) effectively without a lot of redundant or duplicate code?
      3. How do you use the best fit language/technology for UI automation and still do not impact the grand test automation strategies?

      There is an interesting solution to conquer these challenges which I have recently implemented in one of my projects. 

      The idea is to segregate tests from the UI Automation OR webdriver code. This code can be exposed as a web service APIs. Such service allows us to write common tests for UI as well as API. Tests written for API testing can be reused for UI testing with very minimal configuration modification like pointing to appropriate web service. These UI Automation APIs can also be called easily from any performance test requiring UI interaction.

      This approach will enable any test suite using any language or technology in your organization to reuse UI automation seamlessly. This will also make lot of things straight and simple for execution and management across the verticals.

       

      We will deep dive into the technical solution for this in this talk.