Open webinar "Introduction to test automation of mobile applications on Selenium and Appium"

Hello! On the eve of the launch of the Mobile QA Engineer course , we had a traditional open lesson. There was so much information that the webinar lasted for two days ( Day 1 , Day 2 ). In fact, it was a real two-day Mobile QA-intensive , which will be useful to everyone who intends to become a professional in the direction of automated testing of mobile applications on Android and iOS.

---

Lecturer - Dmitry Yarygin, QA Test Engineer with 8 years of experience, 5 of which he worked on a contract with Google .



At the webinar considered:

• what is testing in general and why automation is needed;
• minimal Java basics for automation (variables, objects, classes, OOP);
• What is Webdriver and Appium;
• How to find objects in a web application using various locators;
• Automation of a web application (login on Facebook) using Appium and an Android emulator, and much more.

By the way, if you want to get the most interactivity from these webinars, install the following applications before starting to watch:

1. Android Studio
2. Appium Desktop .

History and features of mobile testing

Mobile testing as a class appeared around 2007 - it was at this time that the first iPhone was announced, which completely changed the entire industry. Yes, mobile testing existed until 2007, but the applications of those times were quite simple and primitive. After 2007, development on iOS and Android became especially active, and this, in turn, could not but affect the testing.



Of course, mobile testing has its own specifics and differs from the desktop:







Despite the apparent simplicity and small size of the gadgets used, in Mobile QA you need to cover a lot of things with testing (sometimes there are even more of them when compared with desktop testing). And who said it would be easy?

Types of Mobile Applications

Mobile applications are:

1. Native (native).
2. Hybrid (hybrid).
3. Web applications (web).

Now look at the following application:







And tell me, what is it: a hybrid, native or web application?



Answer:

Initially, it is understood that the web application runs and operates in the browser, respectively, all interface elements are executed, as they say, in a web style.

As for hybrid applications, this is essentially an attempt to “cram” a web application into a special container and run it in this container, slightly “embellishing” it to look like a native one.



Examples of hybrid applications :







Hybrid applications do not differ in particular beauty: the buttons are still web-based, links are displayed in web format, etc.



Let's look at the features of hybrid applications:







And now an example of a “native” application from the AppStore:







Pay attention to the quality of the interface of this application and to the fact that all the elements look “like native”, because the functionality is fully integrated into the operating system. Roughly speaking, a native application is an application developed taking into account "native" technologies, in our case, it is Xcode for iOS.

The main parameters of mobile applications

The parameters are as follows:

• performance,
• compatibility,
• screen (turns, modes),
• geolocation
• offline mode
• file system interaction,
• work with contacts
• synchronization,
• work with memory
• battery.

Features of testing mobile applications

Now let's get acquainted with the features of testing applications for mobile devices:

Interaction of testers and developers

In principle, interaction practically does not differ from interaction in a normal environment when it comes to desktop testing. All the same:

1. the developer creates new functionality;
2. the tester tests features on various devices;
3. as the bugs are found, the tester creates bug reports and shows the problem areas to the developer;
4. developer fixes bugs;
5. the developer returns the application for additional testing;
6. if there is no problem, the application is ready for release.

OOP for a tester

And now OOP in 5 minutes )). So, if you plan to do automated testing, you should know:

• classes, objects, methods;
• inheritance;
• strings, integers;
• polymorphism;
• Arrays
• redefinition / overload;
• constructors;
• interfaces.

If in a nutshell and without complex terms, then OOP (object-oriented programming) is a combination of data and code for processing them in one object.







Inheritance is a language mechanism that allows you to create a new class based on an existing one.



Encapsulation is a language mechanism that restricts access to the components of an object (variables and methods) and makes them accessible only inside the object (private). In other words, hiding a class implementation.



Polymorphism is the ability of a descendant class to change the implementation of the parent class, but preserving the interface.



Now let's move on from theory to practice , which will help you understand the basics of OOP.

Interactive

First of all, open the following link . We have the following Java code in which there are three main classes:



1. Main:

public class Main { public static void main (String[]args) { Cat cat = new Cat (); cat.setAge (5); cat.setName ("Alisa"); System.out.println (cat.getName ()); System.out.println (cat.getAge ()); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2. Animal:

 public class Animal { private String name; private int age; public Animal() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

3.Cat:

 public class Cat extends Animal { private String name; public String getName() { return "Cat name is: " + name; } public void setName(String name) { this.name = name; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Main is the main class needed to run other classes. The Animal class lists attributes such as the age and name of the animal. The Cat class inherits all the properties of the Animal class (Cat extends Animal), but overrides the existing methods for working with our class.







And now try to solve the following problem yourself:

• make the Dog
  
  
  
  class, inheriting the Animal
  
  
  
  class;
• create a getName()
  
  
  
  method in the Dog
  
  
  
  class that displays “Dog name is: [ ]”
  
  
  
  ;
• create a setName()
  
  
  
  method in the Dog
  
  
  
  class that returns the name;
• in the Main
  
  
  
  class, create an instance of the Dog
  
  
  
  class, set the name using setName()
  
  
  
  and run the getName()
  
  
  
  method to get the name.

The solution to the problem .

Automation. When is it needed, and when is it not needed?

We need automation in the following cases:

• complex application with a large number of screens;
• large arsenal of devices;
• frequent updates;
• a large number of users;
• the application works in many countries and application markets;
• testing speed is important;
• performance testing is needed.

When automation is not needed:

• one or two screens in the application;
• the application operates in one country, in one market;
• rare updates;
• small number of users;
• automation costs will exceed the budget.

Automation: principles and means

Automation principles:

1. Find an object on the current application screen.
2. Check its condition, make sure it is available.
3. Perform actions with the object.

Automation Classification:

1. Automation tools that do not need access to the source code (Webdriver, Appium).
2. Automation tools that require access to the source code (Espresso, KIF).

Automation is, of course, great, but you should always remember that not everything can be "automated".

Automation with Appium

Appium is a server based on the WebDriver protocol (WebDriver is a framework for automating web applications). Appium accepts requests from the client side, converts and transfers them to the emulator or device.







When running, Appium allows you to see all the requests that occur from the client to the server:











What the setup of the Appium environment system looks like:







Friends, we talked only about the first part of the webinar , so we recommend that you definitely watch the video in the recording so as not to miss anything. There will also be talk about annotations in tests, initialization of Appium for Native-applications, search for elements using Appium on Android. In addition, be sure to check out the second part of the open lesson, which will give more in-depth practical knowledge in the field of automation in general and Appium in particular.



And, of course, sign up for the Mobile QA Engineer course, which starts very soon!