Some testing teams set up their own staging environment to test internal servers but as there is no public access which makes it difficult to perform local testing on remote devices. So how would you test your app which can be accessed through your internal network? We launched a feature called Wildnet, that enables you to test private or internal servers using pCloudy. You can test your privately hosted apps on any Android or iOS devices and implement continuous testing to ensure reduced release cycle.

Some times testers want to test their internal servers to protecting unsecured data and credentials, hide new features, and general security. But if an app hasn’t been made public, it should not delay testing across environments. When the Wildnet feature is enabled, a secure connection is created between your machine and pCloudy remote devices so you can perform testing even if the devices are connected remotely.

Let’s see how you can test local or private servers using Wildnet.

Prerequisite:

User should be registered on pCloudy platform
Executables can be downloaded from below links

Linux :
https://content.pcloudy.com/executables/utilities/WildNet_Executables/pCloudyWildNetLinux_v1

Windows :
https://content.pcloudy.com/executables/utilities/WildNet_Executables/pCloudyWildNetWindows_v1.exe

OSX :
https://content.pcloudy.com/executables/utilities/WildNet_Executables/pCloudyWildNetMac_v1

Manual Process to enable Wildnet

1. Run the below mentioned executable command on the terminal:

For Windows:
.\pCloudyWildNetWindows -i Emailadress –k accesskey -u URL

For Mac:
./pCloudyWildNetOSX -i Emailadress –k accesskey -u URL

For Linux
./pCloudyWildNetLinux -i Emailadress –k accesskey -u URL

Example:
./Win-Wildnet -i sample@test.com -k pass123 -u https://app.pcloudy.com

Note: Please use below mentioned URL for-

Public cloud(India): https://device.pcloudy.com

Public cloud(US) : https://us.pcloudy.com

Private cloud: https://private-cloud.pcloudy.com

Note:

User will get authenticated as shown in the below screenshot

This is how users can initiate Wildnet.
2. Go to the Device page in pCloudy platform, connect the device and click on Enable Wildnet as shown in the screenshot:

Open any local URL that you wish to test and enjoy local testing on pCloudy platform.

3. To disable the service simply run ctrl+c to exit

Activating Wildnet for Appium Automation

1. Run the below mentioned executable command on the terminal:
For Windows:
.\pCloudyWildNetWindows -i Emailadress –k accesskey -u URL

For Mac:
./pCloudyWildNetOSX -i Emailadress –k accesskey -u URL

For Linux
./pCloudyWildNetLinux -i Emailadress –k accesskey -u URL

Example:
./Win-Wildnet -i sample@test.com -k pass123 -u https://app.pcloudy.com

Note: Please use below mentioned URL for

Public cloud(India): https://device.pcloudy.com

Public cloud(US): https://us.pcloudy.com

Private cloud: https://private-cloud.pcloudy.com

Note:

User will get authenticated as shown in the below screenshot

2. Once the user is successfully authenticated, they need to add the capability mentioned below, in the Appium automation script.

capabilities.setCapability( “pCloudy_WildNet”, true);

3. Once the capability is added, users can perform local testing on pCloudy devices and verify the execution in live view page.

The most important advantage of Wildnet is that you can be confident about the application as you can rectify all the defects prior to delivery. Try it yourself. Use Wildnet to find more bugs and defects in your internal server before deploying it to production.

pCloudy is committed to delivering the best solutions in mobile app testing and therefore we come up with product updates at regular intervals. This time we are thrilled to announce the release of pCloudy 5.6 with exciting new features to make app testing simpler than ever. Our customers trust us because we believe in exceeding their expectations and add new useful features to enhance the platform’s capabilities. For those who are new to pCloudy, it is a cloud-based continuous testing platform designed to enrich your apps. In this new version of pCloudy, we have addressed the concerns of our users and added new features like Wildnet, Capability configurator, Object spy, and more. Let’s know more about all these features.

Wildnet

An application server is accessible only from within your lab and if you want to test your mobile application with that server, you are forced to work within that lab. If you move with the device in hand outside the lab, you will not have access to that server. How do you test such kind of setup using pCloudy? Because if you are using pCloudy, that means the devices are outside your network. The answer is Wildnet.

This feature enables our users to test private or internal servers on any Android or iOS devices present on pCloudy. For this, you just need to download the executables for OS (Mac, Linux, Windows) on your local machine, Then fetch the user name and API access key for your pCloudy account settings and use it in the terminal to build a link between a device in pCloudy and your internal staging server. To connect a booked device to your internal staging server, you need to click on the Wildnet icon as shown in the picture below.

Object Spy

While creating automation test cases you need the object names of the objects that are available in your application. For example, if your app is launched on a device and you want to click on a particular button, you have to mention the object name in the script to perform that action in the app. Earlier testers used to extract the object name using Appium desktop, but now they don’t need Appium desktop for that. pCloudy now has an inbuilt object spy through which you can run the inspector sessions directly on Android and iOS devices. One big advantage is that its bilateral view which makes it easy for users to click on any element on one side and view the details another side. Also, the generated code can be copied for future use.


In the picture above you can see on the right side we have the object inspector where you will get all the attributes and values for any application. You can select any attribute and perform an action using the tap, send keys, clear and the more option. Following the action, an XPath will be generated which can be used in the automation script.

Data-Persistence

This feature will enable System-admins of our Private and On-Premises cloud to delete older reports based on pre-defined settings. To use this feature, system administrators will have to go to control settings in their pCloudy account and under Infrastructure Management there is an option for Data-Persistence. Whenever any user tests an app on any device in pCloudy, certain artifacts are generated in the form of test reports. Each report will have videos, logs, screenshots, and other elements. These artifacts take up a lot of space so now system admin can delete the older data using the data persistence feature.

As shown in the pic, the system admin can select the date, time and the number of days for which the data has to be deleted. This will help in managing the limited space provided for every team account.

Capability Configurator

In an automation script, we have to include certain capabilities like device name, platform version, etc., to execute the test cases. But now you won’t have to gather the capabilities from different sources, capability configurator will generate the desired capabilities directly using certain filters.

As you can see in the pic, you just need to go to the Devices page in pCloudy and click on the Capabilities tab. Under the capabilities tab, you can choose the parameters like OS, Automation type, Device location, Device name, etc., and the capabilities generated can be copied and pasted directly into the Appium script.

More updates

iOS is a close operating system, and there are many restrictions for testing apps on Apple devices. In pCloudy 5.6, you will have two more functions on iOS devices; close app and lock/unlock the device. The close app function will enable pCloudy users to close any launched application on a connected iOS device using the soft button. The second function will allow any connected iOS device on pCloudy to be locked and unlocked. These two functions will enhance user interaction on iOS devices by saving time and effort. One more new update is that pCloudy now supports Appium 1.15.1 which is one of the latest stable versions of Appium. This will make it easier to perform test automation on iOS 13 devices in pCloudy.

To sum up

The new features added to the platform will help our users to perform live testing on remote devices. Features like the latest Appium support and better user interaction on the iOS devices will empower our users to speed up automation. We are working on some new features, based on our customer feedback, which will be included in the next release. So stay connected for more updates.

Testing framework plays a crucial role in the success of any automated testing process. Choosing the right test automation framework is important as it will maximize the test coverage and improve test efficiency which means a better return on investment.

There are some key points you need to keep in mind while choosing a suitable python testing framework. The framework should justify your testing needs and it should be easy to use. Check if the framework has integrations with other tools and frameworks that you might use. The features, support, stability, and extensibility are also important. So let’s compare the most popular python testing frameworks to make it easier for you to choose the right one.

Robot framework

It is still the most popular python testing framework that uses a keyword-driven testing approach and is used for acceptance testing. To run Robot you will have to install python 2.7.14 or any later version, python package manager, and a development framework like Pycharm.
Advantages

• Opensource
• Platform independent
• No need to learn a programming language to write Robot Framework test cases
• Automatic report generation after executing each built
• Supports behavior-driven, data-driven and keyword-driven approaches
• Easy installation

Disadvantages

• Not enough support for parallel testing
• It’s difficult to create customized HTML reports

Gauge

It is an opensource tool developed by the team that made Selenium. Gauge is immensely useful while integrating continuous testing in the CI/CD pipeline. It is gaining popularity as it supports many plugins like python runner, IDE plugins, build management, java runner, etc.
Advantages

• Quick defect detection
• Easy to write test cases
• Supports multiple programming languages
• Command-line support
• Supports all major plugins
• Cross-browser tests can be automated

Disadvantages

• It is relatively new so it will evolve in the coming years

Pytest

Although Pytest is used for different types of testing, it is more preferred for functional and API testing. There are no prerequisites needed for Pytest, just knowledge of python will be enough to get started. It has a simple syntax which makes test execution easier.
Advantages

• Supports Fixtures and Classes that help in creating common test objects available throughout a module
• It allows the use of multiple fixtures
• It does not require a debugger
• Xdist and other plugins support makes parallel execution easier
• It supports parameterization, which is essential while executing the same test with different
• configurations using a simple marker
• Large community support

Disadvantages

• Test written in Pytest cannot be shared with other platforms

Pyunit

It is a unit testing framework much like Junit but for python language. Also referred to as unittest, it has five core modules. The test loader class is used to load all the test cases and test suites. The test runner shows the result of the test executed using an interface. The test suite is a collection of test cases that are clubbed logically based on the functionalities. A test case contains the actual implementation of the code and the test report contains the organized data of the test results.

Advantages

• No need for high-level python knowledge for test execution
• Extensive report generation
• Pyunit comes with Python package, no need to install any additional module
• Simple and flexible test case execution

Disadvantages

• Requires boilerplate code
• Pyunit is derived from Junit and so it still uses camelCase naming instead of snake_case naming method
• It supports abstraction so the code intent sometimes becomes unclear

Behave

In Behave, test cases can be written in simple language and lets teams execute behavior-driven development (BDD) testing with ease. Behavior-driven development encourages quality analysts, developers, and business managers to work in collaboration to achieve higher efficiency.
Advantages

• Easy execution of all kind of test cases and easy coordination
• Better clarity on the developers and testers output as the format of the spec is similar
• Domain vocabulary that keeps the behavior consistent in the organization and the system behavior is expressed in a semi-formal language
• Detailed reasoning and thinking promotes better product specs

Disadvantages

• Only for black-box testing

To sum it up

All the above-mentioned frameworks have their specialties like Pyunit is used for unit testing and Behave is good for behavior-driven testing. Although Robot framework is the best tool for a beginner to learn the nuances of automation framework. It’s always better to jot down your requirements based on their priority and then choose the right python testing framework.

Test automation is gradually taking over manual testing as it saves time and improves the quality of testing. Especially in the case of regression testing, automation can improve efficiency by manifold. It is a waste of time and resources to do repetitive testing manually. Also, there is a scope for an error as repetitive testing can be exhausting but the chances of errors occurring in automation are slim. But what is automation testing? In simple terms, automation testing is replacing the manual human activity with a system that performs test cases by repeating predefined actions. To get the most out of automation it is necessary to select the right automation testing tool.

Types of Automation Testing Tools

Record & Replay: Tools in this category provide a recording option for the automated script. Every interaction on the screen like tapping, scrolling or typing will be recorded and converted into automation steps. The recorded scripts can be replayed to perform the actions and to verify the AUT.

Coordinate based recognition: Tools in this category interact with the application under test with the help of x/y coordinates, to automate and verify the application.

Native object recognition: Tools that use the native object recognition detect the UI or control elements on their given element tree. This tree is built by XPATH, XML or CSS to identify the elements, verify and automate the script.

Text recognition: Text recognition: Text recognition or (OCR) Optical Character Recognition tools identify elements based on their text. These tools use visible texts to drive automation and to verify the app.

Image recognition: These tools take screenshots of the UI elements in the product to add them to the automation scripts. The AUT will be automated with the help of these screenshots.

A lot of test automation tools support more than one recognition approach which can be useful to get more robust automation scripts. Now let us look at the factors to consider while selecting the automation testing tools.

Platform Support

Are you looking for automation testing tools for web apps or mobile apps? If mobile app then is it hybrid, native or PWA? The scripting language is also an important factor in many cases as mobile automation testing tools do not support all the languages. So if you developed your app using JavaScript then it’s not recommended to use UFT for test automation. In that case, go for a tool like Selenium that is flexible with the scripting language.

There are a lot of test automation tools that support freeware frameworks like Selenium and Appium. Framework integration helps in reducing the effort put into the testing and increasing the collaboration between the teams. Tool integration forms an ecosystem of a collaborative effort that helps in object identification, bug logging, test case management, report sharing, and shared repository.

Ease of Adoption

Ease of adoption can be measured on the basis of the skills required to use the tool and the learning curve. If there are resources available easily on the internet to learn the functioning of the tool then it is a plus point. Also, the support should be good and it’s an advantage if there is an active community that will give a rough idea about the complexities of the tool. We have observed that the installation process is also lengthy for some tools and frameworks. But overall the team should be able to use the tool easily with the skill set or the experience they have.

Ease of Scripting

Most of the automation testing tools provide flexible scripting options. It allows testing teams to write test scripts in their preferred languages. A good test automation tool helps in getting better reusability of test components and provides flexibility in scripts that can be reused across projects. Scripting time with object identification, speed of script execution, support for CI/CD tools like Jenkins, usually these attributes are considered before selecting the tool.

Integrations

If the testing team is using a test case or a bug management tool then the team would prefer an automation tool that can be easily integrated into those tools. It helps in managing the app development lifecycle properly.

The keyword-driven or data-driven automation framework should be easily integrated into any data source. It is convenient if the tool provides connectivity with different data sources easily.

Test Analytics

Analytical reports form the backbone of test automation as it provides insights into the success of the process. Automation tools must provide customizable dashboards to view different types of reports shared across various teams.

Real-time reports traceability and sharing ensure feature validation and efficient test coverage. Quality metrics such as injection rate, defect density, and test execution status allow you to maintain quality at every stage of continuous testing. It’s convenient to analyze results to identify bugs, patterns, and do a root cause analysis with a good automation tool.

License Type and Cost

It’s better to go for open-source tools but not every open-source automation tool has all the attributes that you might be looking for. Even if you opt for the proprietary licensed tools, you need to figure out how much you need to spend on the maintenance.

Some companies offer live support and training for premium plans. So you might want to upgrade to avail of these services. There is also something called runtime license if you just want to execute the automation on different machines. Apart from that, there are options for a node-locked license for a single machine and a concurrent floating license to use the tool on multiple systems.

To Sum Up

If you are still confused and want to further simplify the tool selecting process, then use a tool comparison matrix. Jot down your preferred 2,3 or even 5 tools and then rate them on the basis of all the factors that we have discussed earlier in this blog. This way it will be easier to make a decision on the basis of your requirements.

As far as mobile test automation tools are concerned, device coverage holds the key. It is recommended to use a cloud-based testing platform to run your automated test on multiple devices. Automation is the soul of any CI/CD pipeline and for the successful implementation of DevOps, it is crucial to choose the right automation testing tools.

Espresso is a testing framework for Android which automatically synchronizes your test actions with the UI of your app. It also lets the test wait until all the background activities have finished.

The pCloudy utility uploads your Application APK, test APK and other APK files to pCloudy. It will then acquire a device to run your test on, execute those tests and report back the status and test report.

In pCloudy you don’t have to set up the environment. Just follow these simple steps.

After the test cases are run you can see the detailed reports. Once automation ends, the device under test will be released automatically so that you or other users can use it later.

There are two ways you can execute espresso test cases. Here are the steps for both

1. pCloudy UI Dashboard
a. In pCloudy UI there is a section called Automation where you will find multiple automation frameworks integrated to the platform.
b.Select the Espresso automation and to fill in the required details.

c. pCloudy Support two TestRunners.
i. AndroidJUnitRunner (android.support.test.runner.AndroidJUnitRunner)
ii. AndroidXJUnitRunner (androidx.test.runner.AndroidJUnitRunner)


d. Select your Application and Test Application.


e. Select the required devices.


f. Click on Next button and Schedule the automation by clicking on the Schedule button.


g. You will get a dialog box. Click on Ok.



h. You will get the active session details on the Dashboard and you will also be able to see the Live view.


i. Liveview will help you to see the live execution on your test cases. Click on the Liveview icon


2.pCloudy Utility

a. Download the espresso starter pack from here and Unzip it
b. You will find two files,
i. pCloudy_Espresso.jar
ii.Config.properties
c. Place the config.properties file and pCloudy_Espresso.js file into the same directory.
d. Update the config.properties file as guided in the comments in the file.
e. In your workspace, run the command by typing the java -jar pCloudy_Espresso.jar


f. This will upload the required files which you have mentioned inside the config.properties files.

g. You will get the status of the Automation in pCloudy Dashboard ActiveSession.



h. Even on the pCloudy dashboard, you can use the Liveview by which you can see the running test cases.


i. Once the test execution is over, You will get a URL of the test execution report on the terminal.


j. You can open the report from the dashboard Report section also. In the report, all the test details will be there as shown in the screenshots below.



k. You will also get individual device reports. Inside the test case level details, you will find performance details, test case logs, device logs, and video files.

Quick Links:

• Basics of Appium Mobile Testing
• Appium Setup for Windows
• Writing The First Appium Test Automation Script (Android)
• Starting Appium Server and launching the app from code
• How To Install Appium On A Mac Machine


In the previous blog in this series, we learned how to write the first Appium script for Android devices. Now in this blog, we will understand how to start the Appium server.

The code structure is segregated into three parts, the first part of the code starts the Appium server, the second part stops the Appium server.



The third part is the main method which is necessary to execute the class and from this main method, all the above method are called.

Starting Appium from code requires a path of two files which are kept inside the Appium folder.

• node.exe
• js

Starting Appium Server

In the code highlighted in red, we have called process class which is a Java class and declared it static.



We then created a start server variable and pass the path to node.exe and main.js, highlighted in yellow. In the code highlighted in green, we added both paths into the same variable with spaces and created a method called startAppiumServer() which takes care of the Appium server startup process. Next step is to create an object of Runtime class which is again a java class and call the method getRuntime(), highlighted in blue. We will pass the variable “STARTSERVER” into runtime.exec() method. It will start the Appium Server.

Once the process is started, we have to store the current state of the process into this variable. We will give a sleep time of 5 seconds as it takes time to start the process. what we are trying to validate here is, if the process is not null; it means that the process is started as highlighted in the gray box.


Stop Appium Server


Here we need to create another method named stopAppiumServer(). We again verify the state of the process and if it is not null, call a method of process class destroy().



So now we know how to start and stop the Appium server from code. Let’s try to install and launch an app on a mobile device. Let’s see how we can install a .apk file on an Android device and launch it automatically without providing the path in Appium Server.


Installing and launching the application


To begin with, we call the stopAppiumServer() method to verify if any instance of Appium Server is already running and if so, then it closes that instance, as highlighted in red. The method highlighted in yellow starts the Appium Server.



Then store the apk path file into a variable of File class, which is a Java class as highlighted in blue. Create another variable of File class app. It takes two parameters:


• The absolute path of the apk file.
• Name of the apk file.


Now the absolute path is stored into appDir variable and the name of apk file in the second part as highlighted in the green box. The rest of the things are the same as discussed in the earlier sessions.

The complete code is shown here.







Now that you have learned how to launch app from code, let’s move on to the next blog where we will learn how to set up Appium on a Mac machine.

Quick Links:

• Basics of Appium Mobile Testing
• Appium Setup for Windows
• Writing The First Appium Test Automation Script (Android)
• Starting Appium Server and launching the app from code
• How To Install Appium On A Mac Machine


In the last blog in this series, we learned how to set up Appium for test automation on a Windows machine. Now we will handle the application by writing the Java code. We will require the following software:

Eclipse

Selenium standalone Jar

Appium Java Client


This process consists of five steps as depicted in the picture below.



First, we need to collect the Selenium Standalone JAR and Appium Java Client Libraries. To download the Selenium standalone JAR file, go to seleniumhq.org/download then click on the Download version.



For Appium Java client you need to go to appium.io/downloads and download the libraries for the selected language.



Now to create a java project download Eclipse from eclipse.org/downloads. Launch Eclipse and select the workspace location.



To set the Android SDK path into Eclipse, click on the Windows tab in the menu bar and select Preferences in the drop-down list.



Then select the Android option and browse your Android SDK location and click on Apply.



Launch Eclipse and right-click on Package Explorer. Then select a new Java Project.



Enter a project name and click finish.

Once the project is created, add a folder to the project, for the project dependency files [Selenium Standalone] and [Appium Client Library] which you have downloaded.



Copy the downloaded file into the newly created project dependencies folder. Select both files and right-click. Then select the add to Build path option and then Add to Build Path. Thus both classes have been added to your project reference libraries.



Create a class and import the required packages. Now right click on the src folder, hover the mouse over the new option and select the Class option.



Provide a package name, the name of class then select the main method checkbox.



A .java file within the package is created in Package Explorer panel. An auto-generated the main method is generated on the right panel.



You need to define a public class variable of AndroidDriver as your first line of code. You will now see an error for an android driver. Now hover your mouse over the error, you will get a list of quick fixes. Select Import ‘AndroidDriver’. Once you select the import package option, the android driver package will be imported and the error will be removed.

Create an object of DesiredCapabilities. Again you will get an error for DesiredCapabilities. Hover the mouse over DesiredCapabilities and then select Import ‘DesiredCapabilities’ from the quick fix list.



Once you select the import package option, the DesiredCapabilities package will be imported and the error will be removed.

Now set the DesiredCapabilities and also provide the package of an application and the name of application launcher activity.

Now you need to instantiate the Android driver.

To do this we need to have two parameters, the first is the Appium server address with the port number which it is running and the Capabilities.



Hover mouse on URL and import URL from Java.net. You will get an error for complete new URL section, hover mouse on the error and select Add throws declaration. By doing so exception has been added into your main method.



Now start the Appium server and connect a device to the system. Now return to Eclipse and execute the code. This will launch the app in the device.

In the code, we have declared the class as public so that we can access it anywhere inside out test.



The java main method is highlighted in yellow. We created an object of desired capabilities class which you can see in the green box. In method setCapability, there are two parameters. First is the capability name and second is the capability value as highlighted in blue. Then we created an object of AndroidDriver class highlighted in the black box. The code highlighted in gray is the findElement(By) method which can locate an element on the screen.

Now that you have learned how to write a mobile test automation script using Appium test automation framework, we can move on to the next blog where we will learn how to start the Appium server and launch the app from code.


Related Articles:

• How to use Appium Inspector for Test Automation
• Basics of Appium Mobile Testing
• Inspecting Element on pCloudy Devices Using Appium Desktop
• Help Guide for pCloudy-java-Connector for Appium
• Appium vs Espresso: The Most Popular Automation Testing Framework in 2019

Quick Links:

• Basics of Appium Mobile Testing
• Appium Setup for Windows
• Writing The First Appium Test Automation Script (Android)
• Starting Appium Server and launching the app from code
• How To Install Appium On A Mac Machine


Appium is an open source mobile app UI testing framework. You can test all types of mobile apps and perform automation test on physical devices as well as on emulators and simulators. Appium mobile testing does not have a dependency on mobile device OS and it supports cross-platform app testing as a single API works for both Android and iOS. Appium supports many popular languages like C, PHP, Python, C#, Java, Ruby, JavaScript, etc.


What is Appium Mobile Testing?


When Appium is installed then a server is set up on your machine that exposes the REST API. It receives a command request from the client and executes that command on Android or iOS mobile devices. Then it responds back with an HTTP response. It uses mobile test automation frameworks like Apple instruments or UIAutomator2 to drive the UI of apps.


Approaches to Test Automation


There is two approaches for mobile test automation, Image-based and Object-based approach. Let’s understand both in detail.


Image-Based Approach for Test Automation


This technique of object identification is based on the image processing attributes of the objects in the Application Under Test (AUT). Example: Automate user options like “click, type, drag-drop, mouse actions, etc.”


Visual verification of the expected output


• Not dependent on the platform underneath
• Can be used to automate emulators as well as a real device.



The object-based approach of test automation


This technique of test automation is based on recognizing the nativity of the objects in AUT. This nativity reorganization process for each individual object in the application is carried out using different attributes that are assigned to the object.

It is used to extract the application object identifier with its properties from the actual native operating system source code, just like the developer used. This is an accurate and fast method to recognize the buttons, lists and other objects used by the application.

One drawback of the object-based approach is that the recognition of the individual attributes of the object involved restricts these techniques ability to function in test scenarios that require third-party application access. This reduces the automation coverage of utilizing this technique.



Which approach should we choose?


As we have seen, both approaches have their pros and cons. To get better results, you can merge both approaches and think about devising a hybrid test automation solution.

The combination of OCR (image based) and native (object-based) approach allows users to build a single script that will be portable across different devices. It will make your automation robust and efficient and allows the users to confidently detect the relevant native and GUI defect within the mobile application.


Appium Overview and Architecture


Appium is an HTTP server that manages WebDriver sessions. On iOS devices, Appium proxies command to a UI automation script running on Mac Instruments environment. Apple provides an application called instruments which are used to do a lot of activities like profiling, controlling and building iOS apps. It also provides an automation component where you can write some commands in JavaScript which uses UIAutomation APIs which interact with the app user interface. Appium mobile automation uses these same libraries to automate iOS apps.



The Webdriver Script sends a command in the form of HTTP (JSWP) to the Appium Server. Then the Appium Server will then decide as per the request which driver should be initiated. So, in this case, the Appium Server will initiate the XCUITest driver and it will pass the request to the WebdriverAgent which is an IPA (WebdriverAgent.xcproj) developed by Facebook. WebdriverAgent is responsible to send the command to the Application Under Test (AUT) to carry out the actions in the app. Then the response will be sent to the Webdriver Script through the Appium server.

Only iOS 9.3 and above version are supported by the XCUITest Driver. You can find all the capabilities for XCUITest Driver in the link mentioned below.

https://github.com/appium/appium-xcuitest-driver



The situation is very similar in the case of Android where Appium proxies command to a UIAutomator2 test case running on the device. UIAutomator2 is Android’s UI automation framework which supports running JUnit test cases directly into the device into the command line. It uses Java as the programing language but Appium will make it run from any of the web drivers supported languages.

To answer the question “what is Appium automation?”, let’s have a look at the Appium philosophy.


Appium mobile testing is required for proper execution of continuous integration as it speeds up the overall testing process. Appium mobile testing helps to run the repetitive test which would take more time to perform manually. This is why appium mobile testing is the preferred choice for the developers when it comes to test automation.

In the next blog, we will learn more about Appium mobile testing and how to install/configure the Appium setup on a windows machine.


Related Articles:

• How to use Appium Inspector for Test Automation
• Appium Setup for Windows
• Starting Appium Server and launching the app from code
• How To Install Appium On A Mac Machine
• Appium vs Espresso: The Most Popular Automation Testing Framework in 2019

End to end testing is done to make sure that the application behaves as expected and the flow of actions from starting to end is complete without any issue. To explain with an example, suppose you are the end user and you are using the app to book a flight. So first you will launch the app and click on the flight’s icon on the home page. Then you will enter the destination, date and other required details. Now you will choose your preferred flight, book the seat, enter the passenger details and make the payment. Once this is done, you will get the ticket and a follow-up email on your registered email ID.

Now in this scenario, if the screen takes a lot of time to load the next page or if the book button does not work then this will be an unpleasant experience for the user. So we can figure out if there are any issues from starting to the end of the process. It’s not just about the UI functioning but also the data encryption and security, information flow between other internally used platforms integrated to the app, proper functioning of the firewall and more. This is where end to end testing comes into the picture to make sure that everything works well under any circumstances.

How to Perform End to End Testing

While performing end to end testing the first thing to do is to analyze the requirements and set up the test environment. Then you need to evaluate the main system with the connected subsystems and define the responsibilities of all systems involved. Make a list of the testing methods and the description of the standards to be followed. Once that is done you can create the test cases and track the requirement matrix. Finally, you need to save the output and input data before testing each system.

Measuring the success of the end to end testing

To perform end to end testing efficiently and save time and effort, a matrix should be created. Some parameters should be defined to gauge the success of the testing performed. These measurements will help you define the testing matrix:

Test case status: A proper visualization of the test cases prepared can be observed through graphs and compared with the number of tests that were initially planned.
Tracking Test progress: This measurement will help you to get the details of the tests completed on a weekly basis. It will be easy to keep a track of the test that failed and those that passed.
Defect details: Tracking of the bugs occurred and the issues surfaced should be done one a weekly basis and keeping a track of the defects that were opened and closed on the basis of priority.
Environment availability: Here we need to take a note of the amount of time allotted for running a test in an environment and the time actually spent on performing end to end testing.

Best Practices to Perform End to End Testing

End to end testing can be very time consuming and we can save some time and effort by following some steps. It is always better to plan in advance before initiating the testing process.

Prioritize: Chances of defect increases as the test cases become complex with more components and it becomes difficult to debug them. Therefore it is better to perform unit testing and integration testing to resolve issues that are easier to detect. After initiating the End to end testing you can also start doing smoke and sanity testing to keep an eye on the high-risk scenarios.
Manage the Environment: The requirements need to be documented and the system administrator needs to be informed about it to meet the requirements before starting the testing. The system setup should be proficient enough to run the test cases and keep your staging environment close to the production.
Optimize: After test completion, you need to clear the test data so that the environment is restored and can be used for testing again. This will make the environment ready to start at any moment.
Risk Analysis: Focus on the features that are crucial and on failure can cause a high risk. Prepare a risk assessment matrix which will come in handy in these situations.
Limit Exception testing: Use low-level unit testing and integration testing for exception scenarios and use end to end testing to deal with typical user scenarios.

Conclusion

With the rapid enhancements in the app technology and the increasing use of technologies like IOT, the development teams have to make sure that the app has a smooth functionality. The end users can be very choosy in this competitive market and so it’s necessary to perform end to end testing of applications to provide a good user experience.

Related Articles:

Software testing has evolved a lot since the time when the waterfall model was used. All the work was done in a sequential manner and only after the development phase was complete the testers used to test the product. Testers used to find bugs but a lot of time and energy was wasted in the process to rebuild and code again.

Now companies are using an Agile model where the main goal is to find the bugs in continuous development, fix them quickly and release the app faster. There is a need to improve the automated testing process to complement the manual testing. More emphasis has been given to CI, CD, and DevOps to make the software development effective.

There has been a considerable change in the functioning of testing tools and test automation frameworks. The most important change is the introduction of AI in a test automation strategy.

According to G2Crowd, AI-powered bots are expected to cut business cost by $8 billion by 2022. Testing bots are already empowering automation testing and will play a major role in reducing the time and effort spent in mobile app testing.

Let’s have a look at how AI is breaking new ground for test automation.

1. Running automated tests that matter

It’s not a good strategy to run your entire test suite due to a very small change in your app that you couldn’t trace. You are probably already generating a lot of data from your test runs if you are doing continuous integration. But it will take a lot of time to go through the data and search for common patterns. So you need to know if you make a small change in code then what is the minimum number of test you need to run to figure out if the change is needed or not.

2. Reducing maintenance and eliminating flaky test

We can run several automated tests on a daily basis to ensure the functionalities of the app are still stable. Although, if we find out that half of this test failed. In that case, we would need to spend a lot of time to troubleshoot the failures and investigate the cause. Then there is a need to find ways to fix the failures and then work on the changes.

Using AI we can avoid issues and start detecting issues in the test before they even occur. So instead of reacting to it, we can proactively fix tests. AI can figure out which tests are stable or flaky based on the number of test runs and it can tell us what test needs to be modified to ensure test runs are stable. AI can also handle test running on different resolutions and can optimize the wait time used in the test to wait for the page to load.

3. Dependencies on other modules

Writing a test for systems having dependencies on other modules is also a challenge. AI can help us to mock responses from a database or server. The AI can start recording server responses once we have written the test and have run them for a period of time. So the next time we run the test it will access the stored responses and will continue to run without any obstacles. This will speed up the process as the delay in response is eliminated and the server or physical database is no more needed.

4. Learning from production data

Real user data can be used to create an automated test and with the help of AI, we can observe and learn how the customer is using our product. We can identify common actions such as search option, using filters, login/logout, etc and compile them into reusable components. These components can be used for our test as well. Therefore, we have an actual test written by AI based on the real data along with the reusable components.

5. Easy execution of tests and speeding up the release

In automation testing, the time and effort it takes to write and execute a test is a major challenge due to the complexity of the test automation tools, app, and programing language used. To mitigate these problems AI-based tools are being used. The use of dynamic locators and reusable components has made it possible to write and execute a test in hours which earlier used to take a week.

Conclusion

The DevOps theory says test early, test often, but this puts a lot of responsibility on the testing team. Also, it’s not feasible for testing teams to spend time to do exploratory testing manually for each new release. AI-based tools can perform codeless automation testing which will save us time and resources and give the testers some space to breathe.

Related Articles: