In the world of automated mobile testing, the OpenJS Foundation’s Appium is a big name. However, while it has its benefits, the platform also comes with major drawbacks. In this piece, I take a look at a variety of Appium pros and cons with the goal of assessing whether Appium is a relic of the past rather than a solution for the present.
What is Appium?
Appium is an open source tool used by developers for the automation and testing of different mobile app types (native, hybrid, and web) on various operating systems, including Android, iOS, or Windows platforms.
A distinctive feature of Appium is its cross-platform quality. This essentially means that, through the utilization of the same application programming interface (API), code written on one mobile platform can be reused on any other mobile platform. For example, the same test code written for a Windows platform can be applied to, say, an Android platform.
How does Appium work?
Appium retains a client-server architecture where a client has the ability to connect to a server and subsequently has access to the services provided on the server. The server is able to receive commands and connections from the client and, through extension, execute the command on the respective mobile device, which is reflected with a HTTP response. The automation itself is done in the form of a session that a client initiates with a JSON ‘desired capabilities’ object.
These ‘desired capabilities’ are basically values sent to the server to qualify what type of session the server will implement (or they can even alter what actions the server will implement). The most common distinction the desired capabilities make is the type of operating system the session is running for.
In order to actually execute a client’s command, Appium uses its mobile automation framework to run an application’s user interface. Any results of the testing session are received first by the server and then the client, and are logged accordingly in the client system.
Pros
So let’s get down to hard tacks here. First, it’s important to note that Appium remains popular in part because it certainly has its positives:
- As mentioned above, Appium is an open source tool, meaning that access to its services are widespread. This makes installation and modification easier, and in turn it’s substantially more cost-effective than many other tools.
- The cross-platformed quality of Appium facilitates testing for native, hybrid, and web mobile apps, along with the ability to automate native applications in particular. The issue of recompiling code to match a respective platform being tested is therefore eliminated.
- Appium supports the use of emulators, simulators, and real devices which substantially improves the capacity of testing to reflect user experience and overall usability of the application.
- Appium provides most necessities for app automation within its server, reducing the need for developers to alter any functionality, saving time in the development process
- Appium supports numerous programming languages, including Java, C#, and Objective-C and can simultaneously be integrated into various testing frameworks, allowing for versatile use of the tool
Cons
Unfortunately, Appium also has no shortages of downsides:
- While Appium may have an extensive testing capacity, the tests themselves only provide a relatively generalized report to compensate, so further testing may be necessary to acquire a specific result.
- Appium’s use of simulators is restricted by its inability to run test codes on multiple simulators simultaneously. Thus, the client has to run each individual test code independently if developers desire to receive reliable results for each case.
- Appium currently only supports the Android SDK of API 16 or higher, and generally Android 4.2 and later. This testing restriction severely reduces the amount of Android devices that can be tested by developers. As a result, if Android devices are the intended testing population, Appium may well be a bit inefficient.
- Appium’s functionality does not include automatic image recognition or location. In turn, developers must manually input each image’s coordinates in order for Appium to successfully identify and test their presence. This is highly inefficient.
- Most test automation tools allow for certain gestures to incite a specific action. However, Appium lacks the implementation of some gestures that would otherwise be considered standard. For example, the expected access to a Java client library through double clicking is not supported.
- Appium retains an old client server architecture and hence requires a system administrative overhead unnecessary in other SaaS tools.
So, what’s the take-away?
As of now, Appium is in general considered to be a strong contender for automated mobile app testing solutions. This is due to its broad functionality range. The ability to promote testing across various platforms without needing to alter or recompile code to do so is definitely one of Appium’s biggest perks.
However, even with such abilities, Appium still has its fair share of disadvantages, such as the inability to support older Android versions. This inevitably impacts how effective it may be as a tool for developers. Ultimately, Appium’s compatibility as an automated testing tool will rely on the client’s intended use for it, amongst many other factors.
There are no shortage of Appium alternatives, including Sofy. At the end of the day, performing thorough research on automated testing tools and their qualities will prove highly beneficial for anyone who looking for one to add to their development process so that they may find the best fit tool for them.
Disclaimer: The views and opinions expressed above are those of the contributor and do not necessarily represent or reflect the official beliefs or positions of Sofy.
