Editions Tagged With 'All Platforms'

One of the drivers available in the Appium 2.0 ecosystem is the Appium Roku driver, which enables you to test Roku TV applications.

Appium 2.0 will soon be the only supported version of Appium. What do you need to know about updating your test scripts so that they keep working when you upgrade? This is the first part of an open-ended series detailing the breaking changes you might encounter when migrating to Appium 2.0

In this article we take a first look at Appium 2.0: its goals, its installation, and the ins and outs of the very important new 'driver' command line interface.

On Appium Pro we talk a lot about specific automation techniques, but we don't often talk about the philosophy or the art of testing. Let's do that now, with a thoughtful introduction to what testing itself is.

Sometimes, finding an element isn't enough to tap on it. You call the element.click() command, but nothing happens! By building a tap-by-location helper, you might be able to get things working agian, especially if the problem is that you need to tap somewhere other than the midpoint of your element.

Many apps are not 'single-player,' so to speak. They involve the interaction of multiple users, sometimes in real time. Classic examples would be ride hailing, food delivery, or chat apps. While it's possible to mock out all except one of the parties, to get full end-to-end coverage of these scenarios, it can be useful to run multiple simultaneous Appium sessions, on different devices, to act out the various flows for the various participants, all just as it would happen in an actual use case.

RPA is a massive and growing part of the software industry, focused around the automation of repetitive business processes. While it has its own name and its own use cases, RPA is really not distinct from the tools and processes used in UI test automation. In this edition we take a look at how you can use Appium for all your RPA needs.

This is not a typical Appium Pro article. It's a call for kindness and compassion in the midst of the first, and hopefully the last, major global crisis during the tenure of Appium Pro.

At the end of the day, Appium and Selenium are just web servers. That means we can interact with Appium just like we could with any other REST API, including using command-line tools like curl to generate raw HTTP requests directly to an Appium automation session.

Making sure swiping and scrolling happens equivalently across platforms, and in a way which is super convenient to access from test cases, can be a challenge. In this article I walk through the process of building such a helper in Java.

We wrap up our long series on mobile performance and UX testing with a look at some of the non-free tools or services available to assist with the task. Some of these services provide a way to get performance reports for free as a result of an Appium test. Other tools are standalone products that can be used alongside Appium, but might require some extra setup on your part.

When testing your mobile app's behavior, it's important not to assume fast or even decent internet connectivity to the user's device. One way of seeing how your app behaves in situations where the network conditions are poor is to simulate those conditions locally, either for manual testing or for use in a build scenario.

Having already looked at network and performance testing from a high level, in this article we dive into specific tools and techniques for capturing some of the most relevant performance and UX metrics for mobile apps.

What is mobile app performance? How do we know what to track and how to interpret what we find? In this part-FAQ, part-interview, we explore a host of topics that take us to the edge of thinking about mobile app performance as a significant component of mobile app UX.

Appium and Test.ai have been partnering on bringing AI to open source testing for some time. In this article we take a look at how the technology which powers the Appium element classification plugin can also be applied to Selenium, with reference to special new client libraries created for Java and other languages that can help bring a little bit of AI to your Selenium tests.

In Part 3 of this visual testing series, we tackle the remaining problems that can plague a mobile visual testsuite, including the challenge of full-scroll screenshots and what to do about screen regions that host changing content and can lead to false positive results.

In this second part of the series on visual testing, we think about some of the problems that exist with our home-grown visual testing solution, and explore how the Applitools Eyes SDK is well-suited to making our visual testing more robust and maintainable.

You can use Appium for more than functional testing. Another very important category of testing is visual testing, wherein visual elements of the app are compared across runs to ensure that there are no visual discrepancies, which could be a sign of visual or even functional bugs. This is the first in a 3-part series showing how to use open source as well as industry tools to be successful in visual testing.

When running tests of mobile websites with Appium, it can sometimes be advantageous to work with cookies that have been set in the browser by the application server, using the built-in cookie management commands.

The Appium Events API can be useful for getting a clear look at what's happening underneath the hood of your test, along the dimension of time. Using the Appium Event Parser, you can also generate a timeline to visualize events within Appium itself and within your own test script.

The AI-based element finding plugin for Appium now supports another strategy, namely finding all potentially matching icons on a screen, regardless of whether they map directly to elements.

Finding elements via a template image is a powerful technique for automating apps with non-standard UI elements, as well as games. It can be tricky, though, to know how to appropriately use the threshold setting for finding image elements. In this edition we take a look at a technique for setting this threshold experimentally.

Appium supports a whole host of platforms by means of a large array of 'drivers', each of which is responsible for translating Appium's own protocol to automation behaviors on a particular platform, using a particular automation technology. Learn all about this system, and how to choose the right driver for your testing.

It's all too common to end up in a position where you're trying to debug a test that was run remotely, without access to any of the data that would make debugging possible. Learn how not to end up in this position by setting your test cases to automatically retrieve and save useful debugging information on test failure.

When using Appium with cloud services, we can sometimes be victims of too many network hops and proxies. However, if the cloud service supports the `directConnect` response capabilities, it can make our lives a lot easier.

Appium's client/server model has some disadvantages when it comes to encountering network legacy for each command. Appium has a way around this challenge, by allowing you to batch up commands into a group to be executed server-side.

Deep links are a great strategy for speeding up test execution. However, due to differences between platforms and virtual vs real devices, they can be challenging to implement. It is possible however, by using a mix of cleverness and old-fashioned brute force.

The best way to speed up Android screenshot retrieval is to read screenshots from what is essentially a special type of video stream known as an MJPEG stream. In this article we show how to set up such a stream and tell Appium how to read from it.

Kotlin is a growing language which is very compatible with Java. See how simply a Java Appium test can be converted to Kotlin

Attaching an Appium client to an existing session can come in handy, and now it's even easier with a new constructor for the Java client.

React Native is a popular app development framework that enables native user experiences while maintaining a mostly single platform developer experience. Testing React Native apps with Appium is relatively straightforward, but there are a few tips that might make the difference between a successful and and an unsuccessful Appium testing expedition.

Learn how to use the AppiumServiceBuilder class, which is built into the Appium java client to provide an easy way of starting and stopping an Appium server from within test code.

In the second part of this audio testing series, we look at the all-important step of audio verification, which boils down to determining how similar two different audio files are. This is no easy task, but thanks to the existence of audio fingerprinting libraries, it's one we can handle.

It's not particularly easy, but it is certainly possible to capture and verify audio output for your apps. In the first of this two-part series, we explore the techniques available for capturing audio playback and making it available for later verification.

Google Maps requires some creative touch gestures to zoom in and out, providing a good demonstration of Appium's versatile gesture API

Built-in apps which come preinstalled on devices can be automated by Appium on both iOS and Android. This is especially useful when it comes to automating the settings apps for special test requirements.

Previous articles went over how to capture network traffic on iOS Simulators and Android Emulators during Appium tests, but all the sample code was in Javascript. This edition introduces `mitmproxy-java`, a library based off of `mitmproxy-node`, which allows one to easily run a proxy and capture network requests in a background process in Java.

A look at the pros and cons of the main locator strategies supported on iOS and Android by Appium, and a loose ranking of which should be defaulted to if given a choice.

Using the 'isHeadless' desired capability, you can tell Appium to run emulators and simulators in the background without their graphical user interfaces.

When we're automating mobile web and hybrid apps, it can be hard to know which selectors and locator strategies to use to find particular elements. Tools like Appium Desktop or uiautomatorviewer are no help here, but that's for a good reason: our browsers come with all the tools we need to solve this problem already.

Using the 'mobile:starLogsBroadcast' command, we can open a WebSocket connection to Appium in order to asynchronously stream device logs on both Android and iOS

Running your Appium tests in parallel is great, but using one Appium server doesn't scale to meet the needs of a production CI environment. For that, the best DIY option is Selenium Grid, which is a WebDriver-specific load balancer and proxy. Using Selenium Grid, you can easily add and remove capacity from your test grid, and mix in Selenium-based testing seamlessly alongside your Appium mobile tests.

Did you know that you can use Appium to do all kinds of things, including scripting your holiday donation to your favorite charity? Here's a little example to get you inspired to think out of the box with using Appium as a force of good in the world.

Need to use Appium fixes and features which haven't been published yet? Run from the latest source code

Web Components are an amazing new web standard that promises to ease the pain of code sharing and UI component reuse across your apps and across the web. They do, however, come with a few headaches for testing, since the very thing that makes Web Components sharable and reusable also makes their inner workings hidden from the outside world. There are several strategies for getting inside the Web Component Shadow DOM, however.

There's been a lot of discussion around the potential ramifications of AI for automated testing. While the debate will no doubt rage on, Appium and Test.ai have teamed up to release a simple integration which allows you to find elements using a machine learning model, making it possible to find icons in your app without knowing anything about your app or looking up selectors.

We hear a lot (from Appium Pro and other places) about how it's not a good idea to use XPath. That's generally correct. There are times, however, when it is totally fine to use XPath, or when XPath is the only option. In this edition we take a look at how to write good XPath queries to minimize the XPath blast radius.

We've already seen how to find elements by image, but this doesn't always work out of the box. There are a number of knobs, dials, and switches you can play with (in the form of Appium settings) that help modulate the behavior of the image matching procedures. These will help fine-tune and stabilize your find-by-element usage.

When you just can't find an element, whether because it's built using non-standard APIs or has no uniquely identifying markers, it's possible to fall back to image matching via a template image. This technique, when used appropriately, can help overcome roadblocks to automation.

The ability to automate all the actions a user could take is essential, and that extends to touch gestures like pinch, zoom, and tapping with custom durations. Appium can do all this and more, with its support of the W3C Actions API that allows the encoding of arbitrary touch input behavior.

The best way to achieve a speedy build when it's full of Appium tests is to run those tests in parallel. In this article, we explore how to set up parallel testing locally, utilizing either multiple Appium servers or just a single server hosting multiple sessions.

Rounding out this series on speed and reliability, we consider failure resolution strategies. How do you debug issues? How do you locate a problem in the Appium stack? Where do you report bugs? And so on.

Sometimes you need a mobile software robot like Appium for something other than your day job. In this article I break down my AppiumConf 2018 demo, giving a behind-the-scenes tour of how I managed to coax Appium to act as the director of a software band which accompanied my performance of the original song 'Ghost in the Machine'.

Running into problems with Appium can be a frustrating experience. Sometimes you just get a cryptic, unhelpful message as part of an error thrown in your client code. Where do you go next? The Appium logs! This is a guest post from Isaac Murchie on how to take advantage of reading the Appium logs to help understand what's going on and potentially resolve issues.