Recap: Selenium 2015 Conference

October 4th, 2015 by Greg Sypolt

Portland, Oregon is surrounded by green forests. It’s a bike-friendly city, with an abundance of craft beer, and despite the rain it’s where everyone wants to be. The Selenium Conference Committee wisely picked beautiful Portland for this year’s conference.

Image Source: Test the Web Forward

Image source: Test the Web Forward

Going to conferences always energizes me. It rejuvenates my focus and determination. Why? I discover new concepts from some of the best in the industry, while networking with conference attendees.

One of the best ways to build automation knowledge is to attend the Selenium conference. The attendees this year were extremely technical, and everyone was willing to have conversations about their Selenium journeys.

Pre-Conference Workshops

The pre-workshop Selenium lineup this year was rock solid. The all-day session ranged from beginner to seasoned, and some of the topics covered included: (more…)

Automated Mobile Testing with Real Devices

September 8th, 2015 by Ken Drachnik

Mobile testing has long been a manual process – limited by the devices you have close at hand or at best, a painfully slow process in the cloud.  Sauce has long had emulators and simulators to let you speed your tests by automating them in the cloud. Sometimes, however, emulators are not enough and you need to test on real devices.  We are happy to announce the public beta of our Real Device Cloud. That’s right, we’ve put hundreds of Android and iOS devices up in our cloud so you can automate your tests across emulators and real devices with massive parallelism. That means you can now test fast – just break your tests up into manageable bits and run them in parallel. There’s no waiting, there’s no reservation system – they are available and ready to test whenever you are.

We anticipate opening The Real Device Cloud by the end of the month so you can start testing all your mobile apps.  Download the datasheet.

The Real Device Cloud

  • Instant Availability – Get access to the most popular* iOS or Android devices with no waiting
  • Over 80 mobile emulators and simulators
  • Massive Concurrency – Run your tests in parallel to reduce your total test time
  • Integrate with your CI tool of choice – automate all your tests using the top CI tools like Jenkins, Bamboo, Travis, Team City or Circle CI
  • Test Native, Mobile Web and Hybrid apps
  • Access back end databases – that’s right, you can test your app in our cloud and have secure access to your backend data and websites for a true end-to-end test.
  • Full reporting – instant access to videos, screenshots and all the data for your tests so you can analyse your results quickly
  • Enterprise features – account and team management lets you provision test resources as needed and SSO integration means you don’t have to go to IT to add another tester to your account
  • Professional Services and Training – we have people and partners to help you get started with Appium or if you’re already proficient, our experts can help your team become super users

* The Real Device Cloud will open with Apple iPhone 6 and Samsung Galaxy S4 and S5 phones.  We will be adding more device types in the near future.

Appium + Sauce Labs Bootcamp: Chapter 4, Advanced Desired Capabilities

August 18th, 2015 by Jonathan Lipps

This is the fourth in a series of posts that discuss using Appium with Sauce Labs. Chapter 1 covered Language Bindings; Chapter 2 discusses Touch Actions; Chapter 3 reviews Testing Hybrid Apps & Mobile Web; and this installment is about Advanced Desired Capabilities.

Appium, by and large, supports the desired capabilities you’re familiar with from Selenium. However, given that it also exposes mobile-specific functionality, we have some mobile-specific desired capabilities. We even have capabilities that are specific to one mobile platform: iOS or Android. For the full list of capabilities Appium supports, please see the capabilities doc.

Environment-specifying Capabilities

The main differences you’ll recognize will have to do with selecting which type of mobile environment you want to automate. Appium has adopted the “Selenium 4″ style of session capabilities, which means that, instead of capabilities like this, for example:

[code language=”javascript”]
browserName: ‘safari’,
version: ‘6.0’

You would specify the following, for Mobile Safari on iOS 7.1:

[code language=”javascript”]
platformName: ‘iOS’,
platformVersion: ‘7.1’,
deviceName: ‘iPhone Simulator’,
browserName: ‘safari’

The new capabilities platformName, platformVersion, and deviceName are _required_ for every session. Valid platforms are iOS and Android.

To automate a native or hybrid app instead of a mobile browser, you omit the browserName capability and include the app capability, which is a fully-resolved local path or URL to your application (.app, .ipa, or .apk). For example:

[code language=”javascript”]
platformName: ‘Android’,
platformVersion: ‘5.0’,
deviceName: ‘Android Emulator’,
app: ‘/path/to/my/android_app.apk’

Sometimes we might want to run an Android test on an older device, and so we need to use Appium’s built-in Selendroid support for older devices. To specify that you want to use the Selendroid backend, keep everything else the same, but specify the automationName capability, as follows:

[code language=”javascript”]
automationName: ‘Selendroid’,
platformName: ‘Android’,
platformVersion: ‘5.0’,
deviceName: ‘Android Emulator’,
app: ‘/path/to/my/android_app.apk’

And of course, if you’re running any tests on Sauce Labs, make sure to specify the version of Appium you’d like to use with the appiumVersion capability:

[code language=”javascript”]
platformName: ‘Android’,
platformVersion: ‘5.0’,
deviceName: ‘Android Emulator’,
browserName: ‘Browser’,
appiumVersion: ‘1.3.4’


Appium + Sauce Labs Bootcamp: Chapter 3, Working with Hybrid Apps and Mobile Web

July 6th, 2015 by Isaac Murchie

This is the third in a series of posts that discuss using Appium with Sauce Labs. Chapter 1 covered Language Bindings; Chapter 2 discusses Touch Actions; this chapter covers Testing Hybrid Apps & Mobile Web; and Chapter 4 is about Advanced Desired Capabilities.

Mobile applications can be purely native, or web applications running in mobile browsers, or a hybrid of the two, with a web application running in a particular view or set of views within a native application. Appium is capable of automating all three types of applications, by providing different “contexts” in which commands will be interpreted.


A context specifies how the server interprets commands, and which commands are available to the user. Appium currently supports two contexts: native and webview. Both of these are handled by different parts of the system, and may even proxy commands to another framework (such as webviews on Android, which are actually served by a managed ChromeDriver instance). It is important to know what context you are in, in order to know how you can automate an application.

Native contexts

Native contexts refer to native applications, and to those parts of hybrid apps that are running native views. Commands sent to Appium in the native context execute against the device vendor’s automation API, giving access to views and elements through name, accessibility id, etc. As well, in this context commands to interact directly with the device, to do operations such as changing the wifi connect or setting the location, can be used. These very powerful operations are not available within the context of a webview.

In addition to native and hybrid applications, the native context can be accessed in a mobile web app, in order to have some of the methods only available there. In this case it is important to understand that the commands are not running against the web application running in the browser, but rather are interacting with the device and the browser itself. (more…)

Appium + Sauce Labs Bootcamp: Chapter 2, Touch Actions

June 15th, 2015 by Isaac Murchie

This is the second in a series of posts that discuss using Appium with Sauce Labs. In the first chapter, we covered Language Bindings. This installment discusses Touch Actions; Chapter 3, Testing Hybrid Apps & Mobile Web; and Chapter 4 is about Advanced Desired Capabilities.

One aspect of mobile devices that needs to be automated in order to fully test applications, whether native, hybrid, or web, is utilizing gestures to interact with elements. In Appium this is done through the Touch Action and Multi Touch APIs. These two APIs come from an early draft of the WebDriver W3C Specification, and are an attempt to atomize the individual actions that make up complex actions. That is to say, it provides the building blocks for any particular gesture that might be of interest.

The specification has changed recently and the current implementation will be deprecated in favor of an implementation of the latest specification. That said, the following API will remain for some time within Appium, even as the new API is rapidly adopted in the server.

Touch Actions

The Touch Action API provides the basis of all gestures that can be automated in Appium. At its core is the ability to chain together _ad hoc_ individual actions, which will then be applied to an element in the application on the device. The basic actions that can be used are:

  • press
  • longPress
  • tap
  • moveTo
  • wait
  • release
  • cancel
  • perform

Of these, the last deserves special mention. The action perform actually sends the chain of actions to the server. Before calling perform, the client is simply recording the actions in a local data structure, but nothing is done to the application under test. Once perform is called, the actions are wrapped up in JSON and sent to the server where they are actually performed! (more…)

Appium + Sauce Labs Bootcamp: Chapter 1, Language Bindings

June 1st, 2015 by Isaac Murchie

Appium logo w- tagline {final}-01Welcome to the first in our new series, Appium + Sauce Labs Bootcamp. This first chapter will cover an overview of Appium and its commands, demonstrated with detailed examples of the Java and Python language bindings.  Later we will follow up with examples in Ruby. This series goes from fundamental concepts to advanced techniques using Appium and Sauce Labs. The difficulty is Beginner->Advanced. In Chapter 2 we cover Touch Actions; Chapter 3, Testing Hybrid Apps & Mobile Web; and Chapter 4 is about Advanced Desired Capabilities. (more…)

Recap: Getting Started with Mobile Test Automation & Appium [Webinar]

May 18th, 2015 by Bill McGee

Thanks to everyone who joined us for our last webinar, Getting Started with Mobile Test Automation &  Appium, featuring Siva Anna from InfoStretch and Abhijit Pendyal from Sauce Labs. The webinar covered best practices in implementing Appium to quickly automate mobile application testing. Topics covered included:

  • Mobile Automation Tools and Landscape
  • Setting  Up an Appium Environment & Object Inspectors
  • Writing a Basic Automation Script for Android and iOS platforms
  • Running an Analysis Execution in Appium and Sauce Labs

Missed the presentation, want to hear it again, or share with a colleague?

Listen to the recording HERE and view the slides below.

Interested in learning more about Appium and how to get started? Download our free Getting Started with Appium guide.

Appium 1.4 Released on Sauce Labs, with Better Support for Semantic Versioning

May 13th, 2015 by Jonathan Lipps

Appium logo w- tagline {final}-01

We’re pleased to announce that Appium version 1.4 is now available on Sauce. This hefty release has quite the changelog (see below). We’re also pleased to announce that Sauce now has better support for semantic versioning when requesting Appium versions on Sauce. What does this mean? Well, the Appium team is getting more serious about the meaning behind certain types of releases. We’ve decided that a patch release (i.e., an increase in the 3rd version number, like “7” in “1.3.7”) will signify only an incremental hotfix on the minor version (e.g., “1.3”).

What this means for you as an Appium user is that, if you are using Appium 1.4.0, you should be able to safely upgrade to Appium 1.4.1, or Appium 1.4.2, since we promise not to introduce any new features or remove support for any old features with these patch releases. Instead, patch releases will involve a very small, incremental fix for a regression. As such, we now support specifying Appium versions including only the major and minor version numbers, e.g., “1.4”. If you send in a set of desired capabilities with the appiumVersion of “1.4”, the Sauce Cloud will give you the highest patch release available. So if we have released 1.4.1 and 1.4.2, your tests will automatically be upgraded to those releases if you simply specify “1.4”. Of course, you can always specify a specific version like “1.4.1” if you have any problems. We just want to make it easy for customers to automatically get the benefits of a more advanced and reliable Appium. (more…)

Recap: Best Practices in Mobile CI [Webinar]

April 29th, 2015 by Bill McGee

Thanks to those of you who joined us for our last webinar, Best Practices in Mobile Continuous Integration, with Kevin Rohling. The webinar covered topics like:

  • What makes mobile CI so different
  • Best ways to use emulators and simulators in testing
  • Suggestions for CI tools and mobile testing frameworks

Missed the presentation, want to hear it again, or share with a colleague?

Listen to the recording HERE and view the slides below.


Infographic: Announcing 250 Million Tests Run on Sauce Labs!

April 29th, 2015 by Bill McGee

It’s true! We’re celebrating the fact that more than 250 million tests have been run on our platform! It’s crazy to think that we announced just over 100 million tests at the end of February, 2014. That’s an increase of 150% in just 14 months.

This time we thought we’d take a look at how our ecosystem has been growing as well, including our work with Appium, a cross-platform mobile test automation framework sponsored by Sauce Labs and a thriving community of open source developers. (more…)