Automated Testing on Real Vs Virtual Devices

Automated Testing on Real Vs Virtual Devices

There are key differences between automated testing on real devices and on their virtual counterparts (emulators). Let’s go through a comparison to assess the best path for your organization to take with regard to your test automation practices.

A closer look

Here, we explore the advantages and disadvantages of automated testing on real devices and virtual ones.

a. Advantages of real devices

  1. Testing real world conditions (weather, location, network, etc.) are much easier and provide deeper insight into app functioning in a variety of situations
  2. Screen resolution, picture brightness in different lighting scenarios, etc. are also easily  testable
  3. Interoperability testing is far easier with an actual device
  4. Device performance is faster than corresponding virtual models, which means that evaluating app performance will yield more precise results

b. Disadvantages of real devices

  1. Conducting automated tests on actual devices is a relatively expensive affair, which would hinder projects that are restricted by time and budget
  2. Because of the wide range of platforms and devices, it is difficult to efficiently carry out testing in a limited time period
  3. During the app development phase for unit testing, real devices are much harder to connect to the Integrated Development Environment (IDE) than emulators, which would suffocate the project

c. Advantages of virtual devices / emulators

  1. In situations with severe deadline pressure, getting access to real devices might be challenging, so emulators can serve as reasonable substitutes for testing in such cases
  2. Budget constraints can impact the team’s decision to invest in real devices. Virtual environments can save money and time by allowing testers to continue with their tasks without having to spend on devices that may not in fact be entirely appropriate for the particular tests they want to execute
  3. Emulators tend to be open source and easily downloadable
  4. Web app testing is more convenient with emulators

d. Disadvantages of virtual devices / emulators

  1. For extended periods of evaluation, emulators may not be appropriate because extended usage can be measured best on a real device
  2. The costs may add up when your team discovers that their emulator may be incompatible with certain apps or app elements. In such cases, they might need to invest in software patches to allow testing to continue
  1. Emulators may support only a limited number of mobile operating systems, which could render them useless in many cases

Now that we’ve summarized the pros and cons of each, let’s look at a few testing tools for the Android platform (the most common mobile OS today, so therefore an obvious option to consider).

  1. Robotium: A free UI testing tool, Robotium is often labeled as “Selenium for Android.” However, you need to spend time with the program source code to run your test automation suite, and is not entirely appropriate for interacting with system software.
  2. Ranorex: Can provide comprehensive reports along with pictures, but the element search facility is a little sluggish.
  3. Appium Automation framework: Uses the WebDriver interface to run tests, and supports a number of programming languages, and also supports mobile web browser testing. However, its reporting facility is not very well implemented, and XPath support on mobile devices is poor.
  4. MonkeyRunner: A popular tool where tests are written in Python, MonkeyRunner can run tests on both real devices and emulators. But a crucial constraint in this tool is that you need to write scripts for each and every device. Furthermore, the test need to be altered every time there’s an alteration to the UI of the program under testing.

Thus, it should be clear now that there are a number of advantages and disadvantages to using real devices and emulators, and the kind of tools we should be looking at for the most popular mobile operating system. QA teams need to assess their own project requirements and decide what combination of real / virtual would best suit their needs for a given app, and what sacrifices they’d be willing to make when choosing a test automation tool.

Gallop’s Test automation accelerates regression test efforts in a cost effective manner and our certified test automation specialists have expertise in diverse frameworks and methodologies. Contact us today for your test automation services.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

Selecting a Programming Language to build Selenium Test Automation Suite

Selecting a Programming Language to build Selenium Test Automation Suite

Selenium is a widely used open source, portable software testing framework for web applications. Though Selenium comes with a test domain specific language (Selenese), other programming languages (Java, C#, Ruby, Python) can be used to script tests as well. Tests made in other languages communicate with Selenium via calling methods in the Selenium Client API. Selenium is therefore client language neutral.

All organizations shifting to Selenium for their web app testing face one common question:

What language do we select to build Selenium based test automation suites?

Let’s start off by looking at programming languages as a whole. Though many different languages exist and new ones are still being created, one must note that, roughly 90% of the concepts one learns in a specific language are also applicable to entirely different languages. When one is familiar with the core basics (program design, control structures, data structures, and basic operation of a programming language), developing similar skills with another language simply boils down to understanding the syntactical nuances.

So, which language should one pick? As an individual, the answer is straightforward: go with what you’re most comfortable with.

Dima Kovalenko, in his book titled Selenium Design Patterns and Best Practices, illustrates the flexibility of Selenium, by showing how some common Selenium command sendkeys translate across major scripting languages.

Consistency offered by the WebDriver API across languages, simplifies the process of porting test knowledge of one language to another. Test engineers become greater assets to their organizations as they can be relocated to any web project, written in any programming language, and still be able to create tests for it instantly.

Uniformity between different Selenium bindings is applicable to most commands in the Selenium API. But, one must note that the quoted example is a little oversimplified. Action commands are framed in the same format in every language. But when using different languages to script code, over time, differences will become apparent between the languages. Therefore, actions that function well in a particular language might be redundant and counter intuitive in a different one.

As explained above, no clear favorite emerges when choosing a scripting language for Selenium. But which one should an organization select?

The answer to this question is less straightforward. Some factors have to be considered:

  • The current language being used by an enterprise for development: If an organization has everyone using Python, then that should be the ideal language to use.
    • Introducing a new language isn’t easy. Using a language that QA testers are already comfortable with, is the most convenient choice. It is also much harder to operate Selenium using a new language.
  • Local support for the programming language should also be considered. If local developers are experienced with a particular language, then that language is a better choice for QA teams. In case testers require help with the language, defects, or development tools, it becomes easier to make use of the already available in-house expertise.
  • For individuals who haven’t programmed before, using script-friendly languages like Python, Ruby etc. could be the best way to go. They have an easy learning curve, and also allow Selenium tests to be written quickly and with less code.
  • Java is the most commonly used language, but its scripts can be complex because of the relatively complicated syntax.

When all is said and done, every language has something unique to offer, and so there is no absolute winner. Selecting the most appropriate language comes down to the team’s particular situation, and what they’re trying to accomplish. It is important in this regard to seek some guidance and real-world help from players who have some experience in the field, and whose insights can aid you when making that crucial pre-development decision.

At Gallop, we have in-depth expertise in providing Selenium test automation services. Our Selenium Test Automation Services cover a wide range of browser, OS, and device combinations, and provide an end-to-end cross-browser test automation solution. Leverage the experience of Gallops’ top Selenium experts and Contact us today.


  1. Selenium Design Patterns and Best Practices, Dima Kovalenko

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

How to Add Visual Testing to Existing Selenium Tests

How to Add Visual Testing to Existing Selenium Tests

Selenium is a free, open-source testing tool that is used to automate testing. It is mostly used to test software on their functional aspects and isn’t optimized to include testing on their visual aspects. There exists a strong misconception within the industry on the ease of automating visual testing. These opinions are unfounded as the automation of visual testing isn’t extremely challenging. Therefore, while almost every aspect of testing today is automated, a lot of enterprises still employ the use of manual testing when it comes to visuals. This forms a bottleneck for these organizations when it comes to achieving continuous deployment. Automating visual testing is rather simplistic. Automation is also possible for both new and existing Selenium tests.

What is Visual Testing?

It is defined as the act of inspecting an application’s graphical user interface [GUI] and ensuring it is displayed as intended. It is also occasionally labelled as visual checking or visual regression testing. As the name suggests, the objective of visual testing is to find visual errors. Errors like misalignment of objects, font, layout, rendering issues, etc. It can also be implemented to verify the content on a page, which makes it lucrative for websites with high graphical functionality [charts, graphs, dashboards, etc.].

Visual Testing and Selenium:

Since Selenium isn’t designed to test visual appearance and/or the CSS-Code directly, other approaches have to be considered:

  • By defining style guides
  • Document Object Model [DOM] comparison
  • By running a screenshot comparison
  • By checking the syntax of CSS and HTML

The comparison using the screenshot method is the easiest to implement. With the use of a third-party software, such as Applitools Eyes, one can add testing checks even into existing Selenium tests. Add another program like Sauce Labs to the mix, and one can test across almost every browser, device, platform, and configured in any combination. The many variables involved magnify the operational complexity, but implementing the other existing open source/commercial solutions makes Visual Testing feasible. It adds tremendous value and is also becoming easier to implement with every passing day.

How does it work?

Let’s consider a single automated visual test. During the test a single page is looked at and every distinct element displayed on it is verified to render correctly. Therefore, even on a single page, hundreds of objects are checked for various characteristics [position, overlaps, incorrect rendering, etc.]. A single visual test directly translates into a hundred different verifications. This process repeats itself with each distinct visual test. It can then be scaled to each browser, operating system, device, screen resolution, etc. taking one a few steps closer to continuous delivery.

There are several tools that can be used along with Selenium to perform Visual Tests (for example, Applitools Eyes). Though they might be different from each other, all of them follow variations of the following workflow:

  1. Run the Application Under Test [AUT] and take a screenshot
  2. Compare the screenshot taken with a ‘baseline’ image. [A representative image for the intended GUI]
  3. Report the differences, if any
  4. Update the baseline image as required

Every time a script is run, a screenshot is taken. A screenshot taken initially becomes the baseline image used for comparisons in the future. Every subsequent run, the newer screenshot is verified to be within the mismatch tolerance limit specified for the baseline image. If the mismatch exceeds the tolerance limits, the script fails. Once the script fails enough times, the baseline image can be updated automatically to ensure it represents the newest version of the GUI, but only when instructed to do so. With this method, Visual Test automation can be easily incorporated into existing Selenium tests as well, and the shortened development cycle makes continuous development much easier.

On 1st June, 2015, SeleniumHQ labeled Gallop Solutions as an Aluminum Level Sponsor on their official website, This recognition confirms Gallop’s position as a specialized software testing service provider, committed to making sure clients get value from their QA investments.

Gallop’s Selenium Test Automation Services cover a wide range of browser, OS, device combinations, and provide end-to-end cross-browser test automation solutions. Leverage the experience of top Selenium experts, IP-led testing frameworks with an assurance of world class quality. Contact Gallop Solutions today.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

Successful Test Automation with Selenium and Cucumber

Successful Test Automation with Selenium and Cucumber


Selenium and Cucumber are a great combination when it comes to web application automation, as Cucumber allows you to write your tests quickly in English-like language and Selenium allows you to run on various combinations of browsers. Let us have a look at some details on how to put them together.

The Basics

Web application regression testing is done to assess the app compatibility across a range of browsers, but this method tends to be a burden on both time and money. A better method would be the use of multiple test suites to be driven across a number of browsers.

The obvious benefit of this approach is that errors and glitches get identified early in the production pipeline, and can be resolved almost immediately.

When using Selenium with Cucumber for test automation, tests are written in feature files that can be understood by various stakeholders in an agile environment such as the BA’s. Cucumber also comes with its ability to support multiple scripts and programming languages, the Selenium API is one that allows to drive the browser.

An overview of the process

Cucumber essentially acts as a common ground between developers and non-technical stakeholders. The BDD style is used in writing tests, which is easily comprehensible and doesn’t require any deep knowledge of code (basic commands i.e., Given, When, Then). After the acceptance tests are written into feature files, Cucumber picks the feature steps and executes the step definitions defined in the respective programming language. The Selenium WebDriver API can be called in these step definitions to drive the browsers.

More details

Cucumber does not communicate directly with the applications, it needs to be used in conjunction with tools such as Selenium WebDriver, and Cucumber acts more like an execution framework. Cucumber’s use of English-like language (Gherkin) for its programming function, test case execution is supported with features and scenarios executed based on their definitions.

There are 3 steps for writing automated tests that deliver high value while requiring only low maintenance using Cucumber:

  1. Define scenarios: The acceptance tests are written in English-like language called Gherkin. The scenarios defined are based on the user stories and features defined by the BA team. Sometimes, the BA also creates the Feature files for use by the testing team.
  2. Create step definitions: Once the scenarios are defined, the steps have to be implemented for execution. This can be done in a variety of different languages supported by Cucumber. For instance, if a language like Java is selected for implementation, the necessary classes and methods are defined by creating a project structure. The project can have references added to the Selenium jars, so that the packages can be imported and used to implement the steps to drive browsers using Selenium API.
  3. Define UI Element descriptions: One of the best ways to define UI element descriptions is using the PageObject design pattern. PageObject pattern makes automated test maintenance easier. This is because any changes made to the page elements are abstracted into the PageObjects itself, without the need to update feature files and step definitions.

Concluding Words

We’ve described the working relationship between Selenium and Cucumber here, but there are of course a number of BDD tools that can be used together for the purpose of building test automation suites that deliver high value to your business and do not require heavy maintenance.

Gallop Solutions – Specialists in Software Testing

Gallop is a leading provider of software testing solutions. With our vast experience in testing the web applications, we help our customers to reduce the execution time of testing, leading to cost-effective solutions. To know more about our testing services contact us today.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

7 Reasons to Invest in Open Source Test Automation Frameworks

7 Reasons to Invest in Open Source Test Automation Frameworks

This article discusses seven reasons testing organizations take the open source automation route rather than the traditional automation frameworks.

  1. Inexpensive

The cost of ownership for an open-source test automation framework is considerably lower than for regular testing tools. The major advantage of Open-source is low licensing costs and fairly minimal hardware requirements. Furthermore, testing components are more easily reusable, and their high degree of scalability ensures that they can easily manage load and performance testing. Organizations can also make use of flexible pricing plans that allow testers to adjust their total cloud storage according to their specific testing needs.

  1. Customizable

The open-source software itself can be altered easily to suit a testing department’s particular requirements. This easily editable code allows for smoother functionality, which, in the case of closed proprietary software packages, becomes more difficult, and occasionally perhaps even destructive.

  1. Better support and collaboration

Online communities abound for open-source automation frameworks, which allows testers to overcome obstacles by consulting the vast fields of information available on the web. Teams in different locations can also collaborate via the centralized server, without the need to make several downloads and uploads in the constant flow of information transfer.

  1. Rapid testing

Test cycles with open-source tools tend to be shorter than with traditional tools. Setup and tool deployment are also pretty quick, and there’s no need for a tedious install. Updates happen in real-time without affecting productivity, and the overall time to market is reduced, thereby giving organizations an important push ahead in the endless app delivery race.

  1. Overall quality

Users and developers play a crucial role in creating the automation framework, so such platforms are more likely to be superior to proprietary packages from a technical standpoint. A software suite produced by a small number of developers is less likely to be technically sound than one created by thousands of developers from around the world. A huge number of developers and users work constantly to tighten the security of open-source frameworks, and an equally huge number make innovations, improvements, and enhancements that translate to a higher quality package.

  1. Virtualization

Virtualization allows organizations to make the best use of their resources, which ensures that testing is ultimately more efficient and user-friendly. Virtualization also allows the easy sharing of resources with an associated dip in costs.

  1. Freedom and greater security:

In using open source automation tools, organizations can free themselves of the restrictions of being tied down to one particular vendor. In such cases, the vendor’s priorities make things very inflexible for testing teams: vendor priorities, timetables, usage rules, and various other requirements that greatly limit the potential of all their testing tools. With open source software, however, the decision-making and execution power is entirely in the user’s hands, along with a global community of users and developers that can provide support whenever it’s needed.

Also, in terms of security, open-source software is definitely superior to traditional frameworks.

This boils down to one obvious reason – when there is a larger number of people working on and evaluating a framework, it’s easier to identify and take care of any flaws, errors, glitches, etc. The exact opposite is the case in expensive proprietary software packages, where the vendor gives assurances of security, and the customer can do nothing more than take their word for it and hope they don’t run into any major issues at critical junctures during the development and testing process. The knowledge of bugs in the platform architecture is known only to the vendors, who can take a very long time to patch things up. These delays, of course, detract from customer productivity.

* SeleniumHQ labelled Gallop Solutions as a Aluminum Level Sponsor on their official website, This recognition confirms Gallop’s position as a specialized software testing service provider, committed to making sure clients get value from their QA investments. Learn more about Gallop’s selenium test automation here.


The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

Leveraging Selenium Grid in Public/Private Cloud

Leveraging Selenium Grid in Public/Private Cloud

Selenium-Grid is a method of testing using Selenium that enables simultaneous testing on different devices running different operating systems and browsers; basically a number of machines running multiple tests in parallel. Selenium Grid has two versions at the moment – Grid 1 and Grid 2 – but the newer Grid 2 is now more widely used. It has been designed to follow a hub and node fashion, where a single device known as the hub runs the test, and the nodes are constituted of various other machines that do the execution. Selenium-Grid supports distributed test execution.

When should one use Selenium-Grid?

Usually, there are two reasons for using Selenium-Grid.

  1. To run tests against multiple browsers (even varying versions of the same browser) running on different operating systems on different devices.
  2. To significantly reduce time consumed for a test suite to complete a test pass.

A Selenium-Grid is extremely useful for reducing time on large and long-running test suites by executing the test pass on multiple machines at the same time, thereby dividing the time consumed by the number of machines used. This allows teams using Agile software development to receive test feedback faster. As mentioned earlier, another feature is being able to run tests on multiple environments (browsers, browser versions, machines, operating systems) at the same time.

Since the core idea is to run automated tests with Selenium, the ability to scale your testing is paramount. Therefore, organizations look to build a local infrastructure that can help scale their testing or be able to test against more browsers or operating system platforms. The infrastructure, however, comes at a significant cost, and so becomes cumbersome to maintain. A large organization can afford to run such a setup, which offers its own benefits, such as control over the system, and greater efficiency. But the downsides are high setup costs and getting fault positives because of infrastructure malfunctions.

The alternative is to implement a public/private cloud service to help scale up test suites.

Selenium Grid

Clouds and Selenium-Grid

Using a public/private cloud enables the use of Selenium-Grid on the cloud, thereby entirely eradicating the need for any infrastructure and ensuing maintenance costs. A cloud-based testing bed is much more convenient to implement as depending on the cloud service provider one can immediately gain access to a large number of browser and operating system platforms to be able to test one’s mobile and web applications. Clouds are available for use throughout the day and help substantially increase developer productivity. Also, the use of a cloud provides various feedback mechanisms such as logging, screenshots and video support, thereby appreciably reducing debugging times.

Some of the benefits of using the cloud are:

  1. Support for any new testing platform or updates for existing ones is almost immediate. In the case of using actual infrastructure it could take weeks or months to source the required hardware to run tests depending on the testing platform – for example, a new operating system for a mobile device. But the cloud is updated almost instantly with the latest platforms that hit the market, be it a new browser version or support for a new type of device.
  2. Another feature of a public/private cloud is the ability to scale testing based on one’s specific requirements. It is up to you if you wish to choose to test against 10 or 50 browsers at the same time. The cloud is usually on standby and will create Virtual Machines based on your requests and needs.
  3. As already mentioned before, debugging becomes appreciably easier. Screenshots and videos are recorded at every step, so with this kind of visual information it becomes much easier to pin-point a test failure instead of having to wade through a complex Selenium log.

The only downside to using a cloud is that since one has to use the internet the use of a cloud is usually much slower as compared to a local grid, because the test has to travel to and from the cloud via a network that might not always be reliable. This issue can be worked around by running many parallel test runs, which shortens the overall testing time.

* On June 1, 2015, SeleniumHQ labeled Gallop Solutions as an Silver Level Sponsor on their official website, This recognition confirms Gallop’s position as a specialized software testing service provider, committed to making sure clients get value from their QA investments. Contact Gallop for you Selenium Test Automation needs.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

Challenges and Solutions in Managing Selenium Test Automation Projects

Challenges and Solutions in Managing Selenium Test Automation Projects

Selenium is a well-known open source testing tool, which provides a robust set of tools that supports rapid development of test automation for web-based applications. It provides a vast set of testing functions designed to fit the needs of testing web applications. Operations in Selenium allow many options for locating UI elements and methods to compare expected test results with actual real-world application behavior. It also supports almost all web browsers to run test cases and also supports many different programming languages to help create or modify test scripts. Languages such as: Java, Ruby, PHP, .Net, C#, Perl, etc.

Challenges faced using selenium automation testing, and how to solve them

Selenium at times fails to function correctly if a dynamic event or change takes place during the test cycle. A few common problems faced are listed below, along with how to mitigate them with selenium test automation.

  1. Dealing with pop-up windows: Selenium can sometimes fail to record common popups in web apps. To handle any kind of alert popup, you can apply a getAlert function. Before actually running the script, you must import a package that can generate a WebDriver script for handling alerts. The efficient interface brings with it the following commands: void dismiss(), void accept (), getText(), void sendKeys(String stringToSend). The first two basically click on the “cancel” and “OK” buttons respectively on a popup window.
  2. No event trigger from value changes: Because Selenium does not initiate events with a change in values, one must do it oneself using fireEvent: selenium.FireEvent(cmbCategory, “onchange”);
  3. Timeout resulting from synchronization problems: One should ideally use selenium.IsElementPresent(locator) to verify that the object is in a loop with Thread.Sleep
  4. Testing Flash apps: To automate flash apps with Selenium, one can use Flex Monkium. The application source code must be compiled with the swc files generated by Flex Monkium. Then the app and the Selenium IDE are connected, and the tests can be recorded with IDE.
  5. Unexpected error launching Internet Explorer. Browser zoom level should be set to 100% by default for the IE browser to overcome this error
  6. Protected Mode must be set to the same valueerror occurs when trying to run Selenium WebDriver on a fresh Windows machine. This issue can be fixed by using capabilities as below when launching IE

DesiredCapabilities caps = DesiredCapabilities.internetExplorer(); caps.setCapability(InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS,true); WebDriver driver = new InternetExplorerDriver(caps);

* On June 1, 2015, SeleniumHQ labeled Gallop Solutions as an Aluminum Level Sponsor on their official website, This recognition confirms Gallop’s position as a specialized software testing service provider, committed to making sure clients get value from their QA investments. Attending Selenium Conference 2015 at Portland, Oregon on Sep 8-10th 2015? Schedule a meeting with us.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

7 Core Practices of Agile Test Automation

7 Core Practices of Agile Test Automation

Agile testing helps make test automation more efficient and effective with shortened development cycles. Agile Test Automation bolsters quality assurance and quickens application delivery. Some of the core practices of agile test automation can be listed as follows:

  1. Automation based on coverage: The scope of test automation depends on the amount of code that has to be covered. As part of the test automation execution system, test traceability can be easily understood through test automation runs that are based on code-coverage.
  2. System level automation: In an agile workflow, dependent on team input and user feedback, the UI is bound to experience many changes and multiple versions. So in terms of UI maintenance, test automation tends to be very time-consuming. In order to keep maintenance costs down and enhance overall coverage, automation needs to be conducted at the level of systems and services.
  3. Development driven by testing: Testers need to work closely with product dev teams in cases where the testers first design automation tests and make those tests the foundation for the source code. Implementation of such testing therefore requires persistent collaboration between the different teams.
  4. Automated testing before its manual counterpart: Before automated testing was as widespread as it is now, a round of manual testing was necessary before implementing a round of test automation. But in today’s fast-paced market with rigid demands, teams don’t really have the time to engage in manual testing. They dive straight into the automated environment, but in spite of the efficiency and thoroughness of this process, it would be a good idea for testers to conduct one manual run-through to confirm the stability of the application and get rid of any glitches that the program may have ignored.
  5. Choice of Tool: In an agile workflow, poor decisions and erroneous choices can have detrimental effects that could take a long time to reverse. Selecting the right tools for the job is absolutely key to ensuring successful test runs, and testers can choose from a wide variety of commercial and open-source solutions. Apart from the suitability of a particular tool to a particular automation issue, testers need to take into account a number of other potential problems, such as integration capabilities, installation requirements, overall cost, maintenance, and compatibility with the testing environment.
  6. Verifying test automation code: The automation code itself needs to be tested to ensure consistency and high quality. The code needs to be verified top to bottom, and all issues must be eliminated before implementing a test of any product. In an agile workflow, the pressing lack of time means that the code has to be flawless, and has to guarantee low maintenance costs, reliability, and robustness. In test automation, each step (tool choice, framework design, data generation, test design, code review, execution, maintenance, etc.) is handled in a sequential flow, which means that any automation program is conducted in a traditional testing environment by one single tester who takes care of each step.
  7. Sharing code to encourage code usage across teams: Development, build, and operations teams should ideally be kept in the loop with regard to any given automation code. The advantages of such transparency are numerous – a general increase in the focus on product quality, shorter test and dev cycles, and the free sharing of knowledge to facilitate an efficient workflow. Bringing in people from the non-testing departments brings in new perspectives and approaches to dealing with potential issues, and so the automation code is more likely to be reliable.

7 Core Practices of Agile Test Automation

Bottom Line: Agile development now is a permanent fixture in the modern world. Test teams therefore have no choice but to combine the best practices of traditional manual mechanisms with new product cycles in order to deliver robust, stable, high-quality apps.

Get in touch with Gallop’s Agile Test Specialists who can guide you well on Agile Test Automation and realities of agile testing and help you truly realize the potential of an agile environment.

Mobile testing in agile environment

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

How to successfully automate responsive web applications with Selenium

How to successfully automate responsive web applications with Selenium

The vast majority of software applications today are first written for the web. We’re in an age of incredibly interactive, responsive processes that require Agile testing methods, and so automation is now turning out to be nothing short of mandatory for most software testing programs.

So in the case of responsive web apps, it is absolutely crucial to verify that a particular page is rendered correctly at the most popular usage resolutions. This kind of verification has traditionally been done with a manual method at the very end of a given workflow. The result of such an approach is that there are quite often defects and bugs that delay the eventual release of the app.

The solution is to automate the testing of responsive web apps in order to get the required feedback. But first, let’s take a look at what responsive web design entails.

A definition of responsive web design

This is the approach you take to give visitors an optimal viewing experience – essentially to ease and simply the navigation and reading experience by getting rid of much of the panning, scrolling, resizing, etc that makes other websites tedious. The design covers all devices (desktops, laptops, tablets, mobile phones).

Obstacles to responsive web testing

Because of the sheer variety of devices people use to browse the web these days, there’s a crucial need for testing responsive web apps. The first issue, of course, is ensuring that the website functions well on any device, on any operating system. However, it is impractical to test all the devices in the market. Mobile devices and computers have different interfaces and different methods of user interaction, and therefore a website needs to be tailored to the particular requirements of each device. Therefore responsive web app design needs to account for these differences.

The Solution: Selenium

Selenium is a robust, easy to use toolset that facilitates test automation for web applications. It also comes fitted with a number of testing functions tailored to the requirements of such web applications, and the highly flexible nature of its functionality encourages the easy identification of UI elements. The most important benefit is that the predicted test results can be seamlessly compared with the real-time behavior of the particular application under review.

Selenium WebDriver is an automated tool that takes care of a few critical areas.

  1. The tool can be used together with various other tools to expand the overall test coverage and the number and variety of devices and operating systems on which to conduct the tests.
  2. The tool can take screenshots of the browser pages to conduct a real-time visual check and assess how the localized text appears on a variety of webpages. The screenshots allow quick and easy verification.

Essentials of Selenium Test Automation:

  1. You should first use the Selenium IDE in Firefox to generate a script.
  2. After recording the scripts, identify the locations where assertions are needed, and add them there if required.
  3. Then you can format the test in a language that works best for you.
  4. After converting the script into your selected language, use Selenium Server to run the scripts.
  5. In order to run your script, however, you will require a client driver to support your language.
  6. IDE’s such as Eclipse would also be required to enhance the script.
  7. Finally, the script needs to be integrated and operated in the form of a suite, and for this you would require integration tools such as Maven.

Selenium should be used ideally to verify the workflow, but shouldn’t be put in the main development build. They should instead be allowed to run overnight, on dedicated machines programmed to run these tests.

* On June 1, 2015, SeleniumHQ labeled Gallop Solutions as an Aluminum Level Sponsor on their official website, This recognition confirms Gallop’s position as a specialized software testing service provider, committed to making sure clients get value from their QA investments. Contact us to know more about our Selenium Testing Services.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.

Pragmatic Test Automation with GEB

Pragmatic Test Automation with GEB

Geb is a Web automation framework using Groovy. It is basically a wrapper over Selenium and provides lots of functionalities making the job of test automation easy and quicker. In this post we talk about Geb & Spock (Groovy) automation framework based on our deep experience in implementing test automation solutions across technologies. Needless to say, GEB helps jumpstart test automation with all the cutting edge automation features ready.

By using GEB & SPOCK framework since the beginning, one can definitely gain advantage over typical Selenium Webdriver Frameworks implemented in Java. There are a few major issues with Selenium WebDriver which results in test architects using Groovy automation framework over it. Below are few suggestions to be kept in mind before using Java for Test Automation:

  1. Java is verbose, sophisticated and language heavy. It can be arguably said that it might be an overkill to use Java for test automation.
  2. But Java is Powerful: On the other hand, Java is extremely robust and powerful with tons of features like OOPS, which cannot be used/ implemented holistically in the scripting languages.
  3. Unmatched Open Source Support: Java being one of the most popular web languages, has virtually unlimited support for third party open source tools/utilities and APIs which may remain unused if we step away from Java.

It’s a catch 22. We want to leave Java being an overkill for test automation, but at the same time we want to keep using it because it is full of features and comes with an unmatched open source support. So is there a way, we can use Java without actually using Java?

Answer is Yes, Groovy. Groovy offers:

  • An agile and dynamic language for the Java Virtual Machine
  • Modern programming features available to java developers with low learning curve
  • Ability to statically type check and statically compile your code for robustness and performance
  • Ability to Share base syntax, type system, packages hierarchy with Java
  • Gradle build file ( a groovy script )

GEB Automation Framework:


Geb is a Web automation framework using Groovy. Geb uses WebDriver to test web applications using either real browsers or the HtmlUnit library. What sets Geb apart from the competition is the jQuery-like syntax for querying your HTML pages and its built-in support for the Page Object pattern.

GEB does all the heavy lifting under the hood, eases and improves the productivity of an automation developer manifold.

Few Highlights of Geb:

  • Power of WebDriver
  • Elegance of jQuery Selection
  • Robustness of Page Object Modelling
  • Expressiveness of Groovy

A typical GEB automation script:
The simple,elegant & intuitive scripting as above, makes test automation really easy, fast and effective. This further makes test automation maintenance simpler to update as required with minimal technical complexity, which is really an aid as the test automation grows in terms of size and complexity over the period of time.

SPOCK: Groovy Unit Testing Frameworkspock-logo

The combination of Groovy and GEB is really simple and elegant but the real power comes when it is combined with SPOCK which is a Groovy Unit testing framework (inspired from Junit) which adds lots of much required features in the test automation. Spock is an out of the box framework which works well without compromising the overall simplicity and design of Groovy and GEB framework. There are a couple of strong features which come from SPOCK but it is not a comprehensive list mentioned below:

  1. Data Driven Testing utilising external data sources including text, CSV, excel & databases
  2. Comprehensive Extensible Multi-level status reporting in HTML,XML and plain text formats
  3. Detailed Logs and stack traces for quick root cause analysis in Debugging
  4. Power Assertions
  5. Screenshot Capturing & Screen scraping for capturing DOM structures for later analysis

Selenium Webdriverse-logo

Under the hood, GEB uses powerful Selenium WebDriver APIs which does not need any introduction in the test automation world. In fact, it has become the de facto standard across industry. GEB uses all the power inherited in the Selenium WebDriver API without exposing the complexity to the end User.

cross-browser-iconCross Browser Support

The framework has been designed to specially encounter the most pressing problem in test automation-Cross browser Support. It supports execution on all the standard prevailing browsers, including IE, Firefox, Chrome and more. It also supports headless browser execution for quick turnaround for building verifications and smoke test suites.

Seamless Integration with CI(Jenkins)Jenkins-logo

It has been designed to support CI execution, which has been tested and proven with large scale test automation with Jenkins, which is the standard CI tool for the industry.In the same way it can be integrated with other CI tools as it supports extensively multiple build tools including Maven & Gradle which helps to provide plug and play solutions for most CI test environments.


Cloud Based Test Execution with BrowserStack & Sauce Labs

browserStaks-logoIt has been completely integrated with BrowserStack, which can be utilized over the air for a quick build verificationssauce-labs-logo or large automation suite in any desired environment having support for Cross Platform and across browsers including Windows, MAC, and Linux with IE, Firefox and Chrome browsers.


Apache Maven is an effective software project management and comprehension tool. Based on the concmaven-logoept of an overall project object model (POM), it can be used to  manage a project’s build, reporting and documentation from a central piece of information.


Gradle is a project automation tool that builds upon the concepts of Apache Ant and Apache Maven and introduces a Groovy-based domain-gradle-logospecific language (DSL) instead of the more traditional XML form of declaring the project configuration. Gradle takes the build automation capability to the next level from the Ant & Maven with the grace and easiness of Groovy. This framework works with Gradle completely and can be integrated with a variety of tools further, using Gradle seamlessly and quickly.

Synergy which comes with the integration of all these tools & components, significantly helps to jump start the test automation in most of the settings right away, which in turn accelerates the overall testing process, as observed in a number of our diverse project’s environments in Gallop.

Gallop’s Framework supports complete automation building, dependency management and project creation using all the above mentioned tools which can also be utilized for smooth CI as well as local execution setups across multiple systems.

Gallop’s custom test automation framework integrated with leading tools and reusable libraries makes it easy to kick start the automation efforts.

The opinions expressed in this blog are author's and don't necessarily represent Gallop's positions, strategies or opinions.