Appium Reviews

Our use case for Appium is writing end-to-end tests for mobile applications. We also use it for some data extraction for an end-to-end user desk.

For the particular use case we used Appium for, we felt that it served our purpose completely, and we haven't had any issues with the Python Client for Appium. Appium has been a good solution for us.

I haven't explored other solutions in this particular area, but what I like best about Appium is the fact that it shares functions with Selenium. The extension of Selenium functions allows me to use all of the methods that exist in that domain, and it just makes it simpler for me. I've been using Selenium for some time as well, so using Appium just seems like a natural fit for me.

What needs improvement in Appium is its documentation. It needs to give more context on the libraries that Appium is using under the hood. For example, my team is using Appium for Android automation, and a lot of times, I feel that there's functionality that's available through the Appium interface, that exists within the UIAutomator, but there aren't a lot of useful or helpful resources on the internet to find that information, so it would be good to have some linkage with the underlying platform itself.

Another room for improvement in Appium is that it's buggy sometimes. For example, at times, there's a bug in the inspector application that doesn't allow me to save my desired capability set, so it would be nice to get that bug fixed, but overall, Appium is a good tool.

The Touch Actions functionality in Appium also needs improvement. For example, if I want to initiate a scroll on the device that I'm running Appium on, sometimes Swipe works, but in other situations, I have to explicitly use action chains, so I'm not too sure what's the better approach.

What I'd like to see in the next version of Appium is a more intelligent and more intuitive AppiumLibrary, in terms of identifying menus and scroll bars, etc., because right now, I'm unsure if I have to do a lot of export reversals to get to the elements I'm looking for. It would be nice to have some functionality built in, which would allow me to easily get those exports.

I've been using Appium for almost two and a half years now.

Appium is stable so far, performance-wise. I never had any performance issues with Appium scripts, and I could potentially do as many Appium programs as I want, and I'd only be limited by the compute capacity of the particular machine that I'm running it on, so no issues there.

Appium has decent scalability, and I've primarily used the Appium-Python-Client. What the Appium team could look into would be the possibility of running Appium in a cluster because currently, there's not a lot of in-depth documentation on how to do it.

For example, the way Selenium Hub works with Kubernetes, if Appium can have that functionality of working with Kubernetes, then that would ensure the greatest scalability for Appium.

I've never had to reach out to the Appium technical support team. I'm not even aware of the support channels for Appium, but I haven't had to reach out ever.

I wasn't sure of what other solutions existed out there. I just came across Appium, and I thought that Appium suits my use case, and it's open source, so that helps.

The initial setup for Appium wasn't as straightforward. I was an individual contributor that pitched this idea to my organization about using Appium, and I was solely responsible for researching it, writing code, then deploying it. It wasn't too straightforward, but in the end, I was able to get it done.

I did the deployment of Appium all by myself.

There were implicit monetary benefits that have come from our use of Appium, so ROI wasn't explicit. We got cost savings, reductions in downtime, stability, etc., from using Appium, which translates to ROI.

I'm unsure if there's any cost associated with Appium. I got the free package which includes the server GUI application and the inspector application, and it was free to download, and that's all I need to get my work done.

I'm not aware of any additional costs associated with the tool. Essentially, if you want to run Appium in a production environment, you'll need to hook it up with an emulation service, and though that's outside the scope, that has to tie and deliver the entire solution.

I'm using the Appium-Python-Client version 2.1.2.

In my company, between four to five people use Appium.

The number of people required to maintain Appium depends on the number of tests you've written. In my company, a single person can maintain it.

Right now, Appium is being used pretty extensively within the company. My team runs and tests four to five different applications, and that list will be extended, so usage of Appium will go up in the future. It's not going to go down.

The advice I would give to anyone on Appium for the first time is to look into the underlying automation, for example, the UIAutomator for testing. I would urge you to also look into the different functionalities offered by the base automation and essentially use those features provided by the base automation within that context because that's going to give you the biggest branch of data.

My rating for Appium is seven out of ten, based on the work I'm doing on it.

My company is a customer of Appium.

We use Appium mainly for mobile test automation, while Selenium doesn't support mobile testing. In my personal use of the tool, I primarily convert manual test cases into automated test cases. We also link our test cases between Selenium and Appium with cases from Jira

The solution helps with test automation. We focus mostly on Java.   

One area where I think Appium could improve is in addressing security concerns for our data. Currently, we're unable to use cloud solutions like CloudForm due to security restrictions on our servers. We also face challenges in updating packages for the same reason. It would be beneficial if the solution could provide better support for auto-reporting and easier connections to mobile device farms.

I have been working with the product for six months. 

I rate the product's stability as six out of ten. 

I rate the solution's scalability a four out of ten. 

The solution's deployment is not simple.  

The solution is open-source. 

I rate Appium a seven out of ten. 

We need Appium to do our end-to-end functionality testing. Our company works with mobile automation.

The most valuable features of Appium are the in-built functionality, which we can use in our code. For example, move back, move front, navigate one page before, and navigate one page ahead. You can do this by using the in-built functions from Appium.

Appium can improve when the case fails, there should be a feature where you can generate the report from Appium. Once you're on a test case, automatically the screenshot should be captured which would avoid manual intervention. These features would be beneficial to migrate to Appium.

I have been using Appium for approximately five years.

Appium is a stable solution.

The scalability of Appium is good. 

We have a team of 15 using the solution and approximately 60 other people. Most of the people using the solution are test automation engineers

I rate the support I received a five out of five. 

Positive

The initial setup of Appium is very easy. The process took approximately 15 minutes.

We found out that we could explore features of the solution for 30 days trial. We can switch to a permanent license later if we want.

My advice to others is they should have Java installed on their system initially, then later Node should be set up. They will possibly need iOS or maybe Windows installed, but this depends on their use case. The Appium license should be given by your team member for the tool on your system.

I would recommend this solution to others.

I rate Appium a ten out of ten.

This is the best test automation tool for any mobile test automation engineer.

The solution is deployed on cloud. The cloud provider is AWS.

There are about 30 people using this solution. They're primarily automation testers.

Obviously because of automation, it reduces manual testing efforts.

We haven't been able to fully leverage Appium for multiple reasons. I think number one is just that the tests take a long time to run. We have had some issues around just the results themselves and how predictable they are, but those are not issues with Appium directly. It's helped us to uncover issues that we otherwise wouldn't have known about.

The challenge we have with Appium is we're currently writing the tests in Java, and it does make it difficult because now you need to find automation testers with a Java skillset. That's why we were looking at other tools like Eggplant that would allow us to automate mobile testing through easier mechanisms, like being able to record a manual test and automatically generate the test script for it. We're looking at faster automation and making automation more accessible to their technical people.

I have been using this solution for about five years.

The scalability is good.

We're planning on increasing usage in the future, or we're going to swap to something different. Right now, we are looking at tools that can generate Appium scripts for us, so tools like TestProject and Kobiton and so on. They can generate Appium scripts by looking at manual recordings of manual tests.

Setup was fairly straightforward. We completed deployment within a week.

We used a third party for the initial setup.

The solution is free.

I would rate this solution 8 out of 10. 

There are lots of newer tools on the markets that make testing easier. My advice is to look at alternatives, not necessarily alternatives to Appium, but at least alternatives to generating Appium scripts.

• Automate tests for native apps, hybris apps and mobile websites
• Test executions on real mobile devices and emulators/simulators
• Write automation scripts in any language of your choice Java, C#, PHP, Python and many more
• Based on Selenium API so there is no steep learning curve to understand Appium

We provide IT services and solutions, and with this solution we have helped our clients reduce their manual testing efforts to greater level. Our clients have realized benefits by reducing their testing cycle from three days to three hours through Appium.

They can improve test reporting, and more importantly on test scripts, by providing less constructs to automate more complex testing scenarios.

I've used it for the past three years. We use it alongside Selenium.

Deployment is little tricky but with good help from external vendors organizations, we can implement an Appium-based test automation solution in a short period of time.

There have been no issues with the stability.

There have been no issues with the scalability.

There is great on-line support from the users community. External vendors have innovative solutions build using these tools where they provide tremendous support.

It was difficult to some extent, but with good documentation from the on-line community we where able to implement the tool.

We did it in-house. If you are implementing it for enterprise level its better to seek external vendor help.

We have seen ROI of more than 60%. It's open source.

I would say start lean, gain small wins and incrementally add more. Example: Start automating test cases for one browser and slow expand to multiple browsers.

We use Appium and Appium Studio as our base for any type of mobile automation.

We are using Appium on-premises for scripting purposes. 

Our automation testers download Appium for their scripting.

Mobile app based test automation and Mobile handset experience based telecom scenarios has been automated using appium. This has helped to increase testing efficiency

The interface for mobile automation is helpful for scripting and execution. It's scalable and there are many testers who would like to automate. In terms of scripting, scalability is very good.

It's an open-source solution with a very large community and available documentation.

Appium Inspector helps in identifying the elements very easily. 

The ease of converting is good because it's an open-source solution. The programming language is Java, which is easy to consolidate. It also supports Python.

It is very easy to work with, distribute, and consolidate on a rapid basis.

Stability is an area that needs some improvement. During execution, the Appium Studio experiences some intermittent disconnection.

There are some paid solutions available on the market that have AI included with self healing, which means with changes in application script would detect automatically. The software is smart enough to show you unexpected changes. It can show you the options to change certain element locator which has changed with recent build.

Maybe this additional feature can be added as a paid feature in future.

I have been using Appium for more than one year.

There at times during the execution where there are a high number of test scripts that are being initiated, and during that time the Appian Studio gets disconnected. We then have to restart to continue the flow.

Appian is a scalable solution that is being used almost every day, extensively.

We have approximately 30 people developing, executing, and using Appian. They are made up of automation engineers and DevOps-related who are developing and executing, and we have our team for test executing. 

The community is very helpful. If you run into an issue, you can easily resolve it with the community documentation, where similar issues are being discussed.

It's easy to install Appium. 

When we work with Android and iOS, it is common to have to install other products such as APK as a pre-requisite for mobile app.

We have an automation team to complete the installation and implementation of Appian. We did not use a vendor team.

ROI is good due to ease of scalability.

Appium is open-source, which is not licensed.

We had evaluated two other solutions. For certain tools scripting was easy in Android, but for iOS, there are additional requirements such as instrumentation. This would set us back. We want to use something that is consistent throughout the various OS. They are also paid software, with additional features that are an extra fee. It wouldn't justify the ROI.

Most of the testing that we do requires testing in both Android and iOS.

We chose Appium for the scalability and the ease of automation for both Android and iOS. Appium is a good choice, it's standard. We can use most of the scripts.

Appium, Appium Studio, and Appium Inspector are from the same product family.

Appium is the biggest user base that we have today in terms of open-source. It's not difficult to find a solution when we talk about the maintenance of the scripts.

If you are looking for fast scripting and self-healing features, there are other solutions available that you have to pay for.

I would definitely recommend it in cases where you are using integration automation, you have a relaxed timeline, and stability is the main factor.

I would rate Appium an eight out of ten.

To automate mobile apps, iOS and Android.

The way Appium server interacts with mobile apps is fantastic. It provides all the information about the elements inside the app, Android as well as iOS. I can interact with the element quickly, just type some text or get some text values from the element - whether it's a drop-down, or web text, or a native element.

Initially, Appium had a GUI, for Windows as well as for Mac, and there were some limitations that I couldn't figure out: How to run automated test on multiple iOS devices. However, we figured out that you can run a couple of instances of Appium in parallel, and use them to run tests in parallel, as well as sequentially. 

It's available as open-source for the iOS or Mac, as well as for Windows, so that's a pretty huge feature.

It needs to accommodate applications that use React.js and AngularJS.

Also, an application developed on the Unity platform, such as a gaming application, objects are moving in that case. Interacting with those elements is still lacking in Appium. Appium doesn't have the internal library to play with the Unity platform. That is a huge lack right now.

In addition, on Google platforms we can't use Appium to automate, that is a lack. 

So what I'm suggesting is that Appium should develop a newer, generic solution for all kinds of platforms used to develop applications.

The stability is there. 

I don't think I have experienced any problems with scalability. The scalability is good.

Whenever I have problem, most of the time the solution is available through the  Appium community, as well as through Google searches. I'm an R&D guy so I am able to figure out a solution quickly.

We used commercial tools like Experitest. There were a lot of limitations. For example, we had to use iOS Configuration Utility manager before using that tool. We felt Appium was better because it is an open-source tool. It is very competitive with any of the commercial tools, right now.

I didn't see any complexity in setting up Appium.

Overall, Appium is the best. It is not made as a commercial tool.

I would rate Appium as a nine out of 10 because it has the flexibility, simplicity, and it is elegant. It is technically more advanced, and even a beginner can start using Appium very quickly, and master it in less time.

I primarily use the solution for internal testing.

We can save some workload by using Appium. However, there is a similar workload for the test engineer since we can't reuse the previous test case in the future. A manual test is the same as an automated test in our corporation.

Many reference areas on the web can help you understand the product quite well.

The stability is good.

We do not need to pay for the solution. It’s free.

I can’t think of an area that needs improvement currently.

The setup and installation were a problem for us at first.

Tests can take a long time.

I’ve been using the solution for six months.

The solution is stable. It runs well. However, it also runs slow. The test duration takes a long time.

I don't have any scalability experience.

We have two or three people using the solution. There’s a test consultant, engineer, and architect.

We don’t use it at total capacity. We use it about 30% of the time.

I’ve used documentation in the past to help troubleshoot. I do not reach out to them directly for support.

I have experience with Appium, Tosca, and Parasoft.

The product was a bit difficult to install. it wasn’t easy. We had issues.

It took us four weeks to implement the product.

I’d rate the solution two or three out of five in terms of ease of setup. It’s moderately complex.

There are two of us that can handle the deployment.

I handled the initial setup myself. I had no assistance from outside resources such as integrators or consultants.

The solution is open-source and free to use.

You can pay to extend certain services. However, we never needed to do that.

We are not currently looking into other tools. We also never looked at any other solutions previously.

We are a customer and an end-user.

I’m not sure of the exact version of the solution. It’s likely the latest.

I’d recommend the solution to others. I rate it seven out of ten.