In today’s agile world the time to market is becoming increasingly shorter. There is a constant desire to release ASAP to keep ahead of the competition and to please users with updated/new features. Because of this, we have less time to fully do manual and exploratory testing of our apps. Especially, when you consider all the combinations of OS's, Locales, Accessibility, Orientations & Resolutions apps support. Running anywhere from 1 to 100's of Appium crawler bots (covering all of those combinations) at once we can discover more issues quickly and efficiently without having to write a line of code.

UI Automation also has its limitations as it only tests for expected results. Crawler bots test the unexpected, by collecting metadata such as logs, app strings, screenshots, memory and reporting back it’s finding for review so we can test all these combinations quickly and more efficiently. In this talk, I will go over the current challenges we face in today's development world, why we need more tools to help us keep pace, and cover how you can build your own Appium crawler.

I've open sourced this tool and is available here for everyone to use: https://github.com/isonic1/Appium-Native-Crawler

Apple and Google’s test automation framework does not natively support W3C standards for few web driver spec implementations directly for e.g TouchActions interface in XCTest, etc. Although test automation frameworks support a rich set of those functions specific to platforms, Appium does provide ways to directly invoke these functions e.g gestures, biometric handling, etc.

Many special behaviors and workarounds are made available and achieved only through executing platform-specific native commands of Appium. For instance, there are 100+ issues been reported on date picker or handling picker wheel in the appium organization but it can be achieved quite easily by executing native mobile commands.

There are so many that testers might not get chance to go through each one of these and get acquainted with all of those. Native mobile commands help to handle much complex use cases like biometric handling, talking to Siri, performance profiling, etc quite easily.

Nowadays, more and more companies are building test automation frameworks based on WebDriver and Appium for testing their web and mobile projects. A big part of why there are so many flaky tests is that we don't treat our tests as production code. Moreover, we don't treat our framework as a product. In the talk, you will see examples of how you can automate the testing of your test automation framework and be sure that it is highly reliable. You can get lots of ideas for various types of tests such as learning tests verifying that 3rd party dependencies are not breaking the code, compatibility tests checking that the UI components are working for each mobile control on each OS, cross-platform verifications for testing whether everything is working on multiple OS. Sample test environments for storing different distributions of the framework packages will be presented.

We all know that Appium can do (almost) everything what you tell it to do, but in the end we always ask it to do the same thing. We ask Appium to automate our happy and or our error flow. The result can give us the confirmation that the user can still buy a product, or verify if his bank account still has a positive balance.

But what if we need to know more than that - what if we also need to verify the layout of our app? The answer would be easy, as there are plenty of open-source or paid solutions that can help you with that. However, almost all of these solutions focus on web/hybrid apps, not on native iOS and or Android apps.

I faced this challenge when I was automating a React Native app for my customer. There was no image comparison tool that could do what I wanted it to do, so I rolled up my sleeves and started building my own. In this talk we’ll be walking down the path I’ve been taking and I’ll explain:

• Why I used ResembleJS as my core visual comparison solution
• The things I’ve learned about Appium in the process (pro tips!)
• The differences between iOS and Android and how I managed to solve this in one cross-platform solution
• The pros and cons of my solution

Appium has so many desired capabilities! How many exactly? Let's count!

Join Appium contributor Jonah Stiennon as he iterates through every desired capability supported by Appium.

Many special behaviors and specific workarounds are made available only through desired capabilities. Often the key to selecting an element reliably, launching an app, or avoiding a timeout, is picking the right set of desired capabilities. There's so many that testers don't get the chance to sit down and become acquainted with them all.

There's too many to easily memorize and documentation can be sparse. Jonah will introduce novel ways to classify, visualize, and organize all of the desired capabilities, making it easier to find ones which can be useful.

Experimentation and quick feedback is the key to success of any product, while of course ensuring a good quality product with new and better features is being shipped out at a decent / regular frequency to the users.

In this session, we will discuss how to enable experimentation, get quick feedback and reduce risk for the product by using a case study of a media / entertainment domain product, used by millions of users across 10+ countries - i.e. - we will discuss Testing Strategy and the Release process an Android & iOS Native app - that will help enable CI & CD.

To understand these techniques, we will quickly recap the challenges and quirks of testing Native Apps and how that is different than Web / Mobile Web Apps.

The majority of the discussion will focus on different techniques / practices related to Testing & Releases that can be established to achieve our goals, some of which are listed below:

• Functional Automation approach - identify and automate user scenarios, across supported regions
• Testing approach - what to test, when to test, how to test!
• Manual Sanity before release - and why it was important!
• Staged roll-outs via Google’s Play Store and Apple’s App Store
• Extensive monitoring of the release as users come on board, and comparing the key metrics (ex: consumer engagement) with prior releases
• Understanding Consumer Sentiments (Google’s Play Store / Apple’s App Store review comments, Social Media scans, Issues reported to / by Support, etc.)

Automation has come a long way in assisting with regression testing efforts. Teams worldwide are successfully running hundreds of functional regression tests at every check-in. While this provides a great source of confidence, critical regression bugs are still missed using this approach. That’s because these tests can only assert on what their human programmer asks them to. Additional errors with functionality, UX, and usability often go uncaught using today’s most common test automation techniques.

For this reason, the top companies in all sectors of the industry are turning to visual validation. Visual validation is a relatively new concept that can be used to enhance existing automated tests and provide an easy way to perform those difficult checks for things like UX, localization, usability, responsive design, and cross-device testing.

In this talk, you’ll learn how visual validation works, see a live integration into an existing Appium test code base, and discuss the pros and cons of using various visual validation techniques.

Appium is a world's most popular open source mobile test automation framework developed using WebDriver protocol and I am fortunate enough to get a chance to contribute to appium-uiautomator2-server and appium-uiautomator2-driver modules.

The goal of the session is to help the Appium community to have a better understanding of Appium and how it works.

In this session, I will be discussing Appium architecture specifically towards its Android modules(UiAutomator2 and Espresso), how the communication happens between Appium modules and how to add new handler/API in appium

Every command you write using Appium Client Library will be converted to JSON Wire Protocol over HTTP which in turn will be passed to the drivers(AndroidDriver, IOSDriver). The respective driver doesn’t just send or execute the command directly on the device. Appium has a Lifecycle of modules which sends the command to the devices.

Abstract:

The goal of the session is to help the Appium community to have a better understanding of Appium and how it works internally.

Will discuss on following aspects:

• What happens under the hood when the session is created, mainly how appium connect to the corresponding device, installing the app, launching the app and the different steps involved in the process.

• Command life cycle - How client request converted into an HTTP request, how received request passes through appium drivers(ios-driver & AndroidDriver) and the respective driver don’t just send or execute the command directly on the device. Appium has a Lifecycle of modules which sends the command to the devices.

• How the final response passed to the client through different layers.

Explore the limits Appium can help you achieve to control the Android Emulator behavior. Automate network emulation, receive fake SMS and phone calls, change the battery states and levels and a lot more, all using real-life test cases. What happens to my app if I lost connection? How does my UI react to an incoming phone call? And more.

https://slides.com/vrunoa/appium-conf-2019#/

https://github.com/vrunoa/appium-conf-2019

Testing our mobile application using real device is not scalable and need high maintenance. As the test is bigger , we need to make our test is parallel to make it faster and efficient. We also need to test it agains many variety of device and OS version. Running testing using device cloud is the solution, so in this session I will show you how to setup and run parallel automation testing using Android device emulator and iOS simulator. In this case, I wil show the demonstration using Genymotion Cloud, Appium, and Robot Framework.

When we speak about Android automation, the first thing that comes to mind is Appium, however, what if Appium doesn't serve all your Android automation needs, at least not in the most efficient way?

When I was asked to create a test automation framework for our android service (no GUI), I needed to choose the right tool for the mission. After several weeks of researching many options (both commercial and open source). I realized that ADB is my best call because of the following reasons:
• ADB provides a faster to run solution for controlling an android device
• ADB is in a lower level of Android OS therefore it's more flexible
• ADB is going through less code components (like appium client, appium server etc..) and as a result is more reliable

In this tutorial I will share my journey towards deciding to use Android Debug Bridge when it comes to non-gui android application and how I have implemented my choice.
After this tutorial, you will have a better understanding of what is ADB, how it works, and how you can start and apply automation for the Low-Level layer of Android OS with ADB and Python.

Instead of buying test devices and maintaining them on-premise, there is an ongoing trend to facilitate cloud providers for UI test automation. This talk will explain the basics and provide an overview of the advantages and limitations of this approach. It will also tell the story of how we moved from running a handful of tests against four of our own test devices to executing 100+ scenarios (and counting) on AWS Device Farm, Browserstack and a local simulator farm.

The need for test automation nowadays is undeniable. For choosing the right solution for our context, we need to know what are our options and fully understand them. We will talk about the five generations of test automation frameworks, what they include, who uses/used them and how they are related to the evolution of the QA profession.

The full-stack test automation frameworks are the 5th generation of tools. You will hear why they are different, what they include and why this is important. Understanding the evolution of the automation tooling entirely will help you define better the requirements for your test solution or give you ideas on what to improve in your existing one. As a bonus, you will see demonstrations of sample features of such a framework and get inspired how to build them yourself.

We're all hearing the buzzwords of AI, machine learning, chatbots, and next-generation testing. Does this mean that the days of traditional testing as we know and practice it are over? Eran Kinsbruner doesn't think so. Join him to learn about the clear transformation happening toward smarter testing techniques and tools. These approaches will drive better pipeline efficiency and release velocity with high quality, and Eran thinks this means good things for the testing practice and practitioners. You'll discover the key trends that are happening around AI, machine learning, and bots in the web and mobile landscapes, and get the ability to identify some early adopters who are taking the lead in these domains. Learn some key requirements and skills that are required for a test engineer to shift toward the future of automation, as well as the changes testers will need to undergo in order to become future leaders in this space.

Promising a convenient life by enabling machine-to-machine and machine-to-human communication, IoT (Internet of things) technologies are fast gaining ground. In the not-too-distant future, we might see refrigerators automatically ordering items that need replenishing and cars steering us around on their own. This means designers, developers and QA engineers will have more opportunities than ever before to significantly impact the lives of millions.

There will never be enough QA engineers for testing IoT offerings, because there will be numerous layers and devices to test for functionality, interoperability, security, and more. Although a certain high level of manual testing will be required for , having more to test means that they will need to prioritize and automate whatever you can. This would increase the demand for better automation testing, leading to a rise in the number of sophisticated testing models in the connected world.

APIs connecting our connected world should be automated as much as possible because without a fully functioning API, there will simply not be connected to the Internet anymore. Creating API tests manually, based on a written description, can be time-consuming and inaccurate.

An API, typically based on JavaScript Object Notation (JSON), is often layered on top of the transport protocol. This transport layer helps interact with the device. Automation Engineers can use these protocols and APIs to automate IoT devices. The Automation framework must be able to support these protocols and APIs in order to be effective.

An IoT gateway helps connect smart IoT endpoints with sensors over cloud. With the help of the rest APIs of the IoT endpoints we have developed a test environment where all APIs are integrated with our automation framework.

In this talk, we will demonstrate how to integrate established connection between IoT endpoints and cloud server with automation environment to help teams to bring APIs into automation of IoT devices which helps in detecting reliability, functionality of IoT endpoints.

This session will talk about how testing not only verified the features work as expected but also ensure the user interface produces the right output. UI testing is more closely associated with the device or emulator than with the platform language. This enables to record a UI flow on one device and then replay the test to other devices.

Based on my own experience, UI testing with the manual test is so frustrated when we have a new build every day especially if we have a lot of test cases need to be verified before the product goes to market. With the power of image processing, Automated UI testing is possible to created which is really helpful to reduce the testing time.

I would like to share how the team in BBM implemented the automation to automate the UI testing. comparing some of the existing libraries that supported robot framework and try to create the extended library to fulfil the needs.

While we work on Functional test Automation, as Automation engineers we get lot of functional tests which require multi user login concurrently.

I would like to discuss on effectively Automating such scenarios.

BBM relies on hundreds cross-platform automation tests written and maintained by 45 test engineers. I will speak on our experience of revamping the ~ 75 machine infrastructure that consists of virtual devices (Genymotion and XCode) installed in several Macs, Ubuntu boxes, and on-demand cloud instances. I will not just give you the actions taken, but also conditions that influenced that decision making.

Appium is the leading open source and de facto framework for cross-platform iOS and Android mobile functional test automation. That’s nothing new.

With constant changes in the mobile space, and together with the ongoing DevOps transformation, teams are challenged with the objective of enhancing test automation coverage, stability, and delivering valuable feedback to the mobile app developers as quickly as possible.

Additionally, quite often app developers and testers naïvely approach testing by following test steps, rather than testing from the end-user perspective.

Lastly, the testing ecosystem is divided into various practitioners with different skillsets following different methodologies.