Manual Testing For The Less Technical Tester

How would you feel if an airline told you that an automated system would replace the pilot during your entire plane ride home?

Would you hop on the plane? Probably not. Similarly, any mobile app tester knows that some manual testing must take place before an app’s release despite amazing advances in testing automation.

Because manual testing is so important for mobile apps, Kobiton offers easy-to-use, robust manual testing options within its platform. With only a basic understanding of coding, testers can increase the power and thoroughness of their manual mobile app testing.

In this post, we’ll provide an overview of the basics of manual testing, why it’s important, and how our platform makes it easy.

Why Is Manual Testing So Important?

When you test an app manually, you are able to view it through the lens of a real person using it on a device in the real world. Many bugs and issues are not apparent with automated testing because of the sometimes irrational, random, and emotional aspects of how a user interacts with a mobile app. Like automated testing, you’re still looking for bugs and issues. But manual test cases involve a different approach for good reason.

Some important areas where manual testing works best include:

• Design aesthetics: How does the mobile app look and feel aesthetically? Does the design look good? Do users like how it looks? Are there any design elements that make your app look bad or feel wrong?
• Common “wear and tear” actions: Remember that users won’t always use your mobile app in the most sensible, straightforward, and rational way. Is it easy to open, close, and operate the app without much effort? If someone taps icons quickly, uses one hand, or flips their phone upside down repeatedly, will the mobile app still work smoothly and properly?
• User satisfaction: Do users have issues you did not anticipate? These may not be bugs but instead obvious annoyances and frustrations about how the app works that developers would never see.
• New functionality: Does new functionality work properly from a usability perspective? Does it make intuitive sense as a human using the app? Is the new functionality easy to find and use
• Hard-to-find bugs: Are users reporting a hard-to-find bug that automation is not identifying? Can you replicate the bug manually based on user feedback?

Creating Manual Test Cases

With manual testing, the way you design test cases is crucial. You want to thoroughly test a variety of correct and incorrect inputs along with replicating various user behaviors to make sure your functionality is solid.

As an example, let’s look at a sample test case for manually testing a flight reservation app. Your test steps may include:

• Check whether the page is possible to log into without providing any user details.
• Log into the page with a valid username and invalid password.
• Log into the page with a valid username and valid password.
• Check whether the application is accepting the date in DD/MM/YY format.
• Check whether the application is accepting the date in MM/DD/YY format.
• Check the date by entering the same in MM/DD/YY but execute the test by providing the single digit value for date and month (such as 6/7/13).
• Check whether the app is showing the availability of the flights with the date and timings of each departure.
• Check whether the application shows the details of the passenger’s order once it is placed.

You may also want to develop a protocol for manual test cases that includes items such as:

• A unique test ID
• A description of your test
• Preconditions
• Test data
• Test steps
• Expected results
• Actual results
• An indication if your app passed your test or not

In a future post, we’ll talk about best practices related to creating a test case protocol.

How Does Manual Testing on Real Devices Work?

Whether you are holding a device in your hands or accessing a real device over the Kobiton cloud, manual testing works similarly within our platform. After logging into the Kobiton portal, you will complete the following steps.

1. On the Kobiton dashboard, go to the Devices menu, hover over the device you want to test, and click “Launch Device.”

It’s here that you select the device you want to manually test. You can connect your real device to the Kobiton platform or access a real device from our cloud library that includes hundreds of the most popular device configurations. If you connect a device that you own into our cloud, other members of your team may test it no matter where they are located.

2. Go to the APPS tab to upload and install your iOS or Android binary file (IPA/APK).

Your binary file is usually the executable file for your app. You can install the app onto the real device by:

• Selecting your app from the Kobiton app repository. Here, you will find all mobile apps that you and other authorized testers have already uploaded.
• Selecting the app from your own machine using a third-party URL or file upload option.
• Note that some coding knowledge might be required when installing the mobile app onto the real device if you’re using the URL installation option.

After installing the app, you can use the touch option in the toolbar to open the app on the device just like you would if you were holding the phone in your hand.

3. In the Sessions tab, name and fill out a description of the session.

In this section, we recommend:

• Naming your manual test session (so it’s easier to find in your list of test sessions).
• Describing the test objective in the test session description.
• Setting the screen quality (to low, medium, or high) depending on your network speed. (Kobiton optimizes the rendering rate based on your connection quality, location, and device availability).

4. Follow your test case.

Using the options available to you in the toolbar, you can perform a series of desired actions that follow your test case. These options function similarly to holding a device in hand and include:

• Multi-touch gestures and interactions with the device (including touching the home button, pinch zoom, etc.).
• Rotating the device between portrait and landscape mode for different orientations.
• Turning the power off and on.
• Activating hardware features like the camera, microphone, or GPS simulations.

As you manually test, you can also expand the device screen to full view and perform a screen capture of the device. While you’re testing, Kobiton is recording your test sessions and storing the session details so that you can later access them as needed.

Figure 1: Kobiton manual test screen for a device.

Figure 2: Manual testing touch control toolbar options for the device.

When you’re done testing, just return to the device’s home screen and select Exit to close out the test session.

5. Analyze your test sessions.

In addition to the observations you’ve made about the app during the test session, you can also analyze screen captures in the “Screenshots” section, download a screenshot by clicking the download icon, and analyze device logs (that capture all actions) to look for bugs and issues via the “sessions” tab.

—

Overall, with minimal coding knowledge, Kobiton allows you to easily upload an app to a real device, manually test it as if it’s in your hand, and examine plenty of detailed results all in one place. This ease of use not only accelerates your manual testing activity but it also makes it more accessible for less technical testers.

While automated mobile app testing is a little more complicated, Kobiton still makes it easy to accomplish on our platform. Stay tuned for our next blog post that provides an overview about automated mobile app testing.