Managing development projects is always a challenge, but how are test automation projects different? What are the thing to hold in mind, the obstacles to obviate and the tool to take reward of? In this article, we are locomote to share our experience with you.

Before we start into the details, let us say there is one mean brute you will experience to deal with during an Appium-based test mechanization project, and that is maintenance overhead. The final purpose of a lot of the things you will be doing throughout the project will be to keep this overhead down to a manageable level. But what is maintenance overhead in this context?

Maintenance overhead

To put it simply, maintenance overhead is the sum of all the time and resources you will have to spend on adapting or rewriting constituent of your test codebase for the length of the project.

It is the one single constituent that, if not properly managed, is most likely to become a potentially successful Appium automation task into a failure, and one that let very well overlooked by citizenry with no former experience on scaling test automation infrastructure. But what regulate alimony overhead, and how? Among the most important element, we can find:

• Speedy change in the application under testIf your tests are not working because one of the UI elements you are see against is precisely not there anymore in the latest app build, they are not useful anymore. Keeping up with an evolving coating in an Agile environment is not something that happens on its own, it requires a well-rounded procedure in place.

• Testing on multiple platformsCross-platform automation is really neat, but comes at a toll. If you have an Android and iOS version of the application and they are not utterly aligned and have near-identical flowing and functionality, you will feature to increase the complexity of your testing setup to conduct fear of these difference. And, in turn, this means more points where your setup can separate.

• Testing on multiple OS versionsMobile go systems evolve over time, so it ’ s no surprise that if you are testing across a broad range of OS versions, you might experience to adjust to some major changes that hold occurred over years of development.

• Testing on multiple devicesSupporting different form factors can definitely increase the amount of time spent fine-tuning your tests. Depending on what you are doing, device performance can arrive into the picture. Believe it or not, sometimes yet unexpected details, such as the device manufacturer, could influence how your tests run.

• The app itselfSome apps are easy to automate, while others aren ’ t. Appium excels at targeting standard UI element, but thing like function, custom widgets and artwork (opine mobile games) are not really its cup of tea. And sometimes, for the most different intellect, you might experience a hard clip testing one or more specific features that looked really much touchstone at first glimpse.

To make this clear, let ’ s consider a couple of examples.

Low maintenance overhead

Let ’ s say you are compose appium tests for a small client who is developing a mobile application for Android devices. Specifically:

• You are the solitary technologist working on this small project, and your contacts are internal to your society and quick and effective in providing you any information you might need;

• The app is only meant to be run on latest-generation Android smartphones;

• The application, which is already live in the app storage, is evolving real tardily from update to update, commonly with alone minor changes done to its UI, of which you get even apprize beforehand;

• The app is easily automatable: you know the developer personally, and after your requests they have be kind enough to cater IDs for each and every element in the application, so that everything is nicely accessible without any issues.

This translates to:

• Quick info exchange with the citizenry who can render the info you need to proceed the automation process rolling smoothly;

• No cross-platform or form constituent related pains;

• Minimal changes to the application means tests stay relevant longer and are easier to update

• Tests are easy to write and run reliably.

Of course we would be lying if we told you that this is a real-world representative: what we just report only served the purpose of illustrating what we imply with “ low maintenance overhead ” situation. Run-of-the-mill test automation projects are ordinarily jolly in between this variety of position and the one shown in the following example.

Pro tip: Tools like SUSA can handle this autonomously — upload your app and get results without writing a single test script.

High maintenance overhead

Now, while keeping this same metric in judgment, consider the followers, very much different scenario:

• You are managing a team of five engineers;

• The client you are dealing with, a declamatory enterprise, puts you in a position in which all of your contacts need approval from a supervisor before they can give you any of the things you need;

• The app is cross-platform and is supposed to act (and to be test) on all Android and iOS smartphones and tablet release in the final years;

• The Android and iOS apps are not adjust, with the app feature different features and looking quite different on the two platforms at this point.

• Some of the feature you are supposed to quiz are really not trivial to automatize.

• The coating is in an earlier stage of growing, which mean you are getting a new version of the app every week, sometimes with major changes to the UI and stream.

In hardheaded terms, this render to:

• Keeping course of the status of the project is a full-time job, and communication with the client expect both quick conclusion fashioning and careful preparation;

• The apparatus will need to cover a number of prodigious cases, and your tests will require a great deal of work to be reliably act on a variety of different devices, operating systems, operate system versions etc.;

• You will need to adapt your test very frequently, with entire tests needing well-nigh complete rewrite every release.

This is the quintessential “ high maintenance overhead ” situation. A project of this magnitude will need several times the resources of our previous, terribly optimistic exemplar.

Five Questions to Ask Yourself When Evaluating the Complexity of a Test Automation Project

What we just said highlights the importance of realize the complexity of the project from the rattling beginning (be mindful that this is also considered one of the toughest tasks in the battlefield).

Do not expect everything to be crystal clear from day one, but try to answer these fundamental questions betimes on:

1. How many test cases need to be automated on how many platforms? On how many different OS edition?

2. What will the average test case look like? What will its complexity be?

3. How does the application face like? Is it automation-friendly? Are its characteristic well testable with automated tools?

4. How often will you get a new testable edition of the coating? How rapidly is the application changing?

5. What sort of device coverage will you need to aim for?

Remember that, while we are dive into the issues specific to test automation undertaking, you will likewise be facing the more typical problems that are encountered when tackling software projects, such as communication mishaps, people problems, duplicate of endeavour and so on. These will also contribute towards the overall complexness of the project, so don ’ t forget to factor them into your appraisal and considerations.

Setting up the process

Anyone who has ever led any sort of timeboxed project cognize how crucial it is to start on the right ft. The first few day before your project kick off might very good be the most important of them all. Time invested betimes on into coming up with a clear strategy on how to take on the project might be the one that will bring the large bribe. Among other things, you should definitely experience a open idea about:

• The overall workflow your team will be following to implement the tests; How are you going to ensure team-wide collaboration that works synergically with the rest of your apparatus? (Git Flow, as good as its variations, could be an illustration of this);

• What kind of tools you will need to put in place to grant frictionless communicating and collaboration with your teammates (and possibly with your client);

• How you are going to keep course of the status of the tests across multiple device and platforms;

• How you are going to make sure switching to a more recent application version won ’ t make you lose track of the current project status;

• How you are going to check your tests run reliably;

• What sort of guidelines you will get in place for writing codification / reporting issues / near automation challenge;

• How you will deal to commute feedback with your teammate in a seasonable manner;

• How you will monitor the overall projection position over time;

• How you will distribute obligation between your teammates and boost autonomy.

At TestObject, we are routinely working on kickstarting our enterprise customers ’ test automation infrastructure. This mean we are leveraging our deep knowledge of Appium and wandering device testing to quickly automatize a tumid number of test cases on one or more platforms.