Thu, Jun 13
Registration - 30 mins
Pooja Shah / Anand Bagmar / Bruno Alassia - Getting Started with Appium
You always wanted to start Mobile app Automation using Appium but did not know where and what to start with? Or started but got stuck among understanding capabilities, locating elements, finding whats wrong and your daily work deadlines? Yeah, we all have been there. Hence here is this workshop, precisely designed for beginners to quickly get started with Appium in NodeJS.
At this workshop, you will learn everything from the scratch step by step. We will together understand the key concepts, apply them right there and write our “first test” in appium before we learn more nitty-gritties as takeaway for you to go and implement at your actual work directly.
Think of this as a one-day crash course in Appium. The course will be prepared in NodeJS but there will be help for those who want to get started in Java.
Srinivasan Sekar / Sai Krishna - Advanced Appium
At this workshop, you'll learn about advanced concepts in Appium. We will learn how to write a single script for Android, iOS and mobile web apps. Once our tests are established, we will work on framework design and report. We will also have a detailed look at how can we automate various mobile gestures using TouchActions and mobile endpoints in Appium.
ManojKumar / Diego Molina - Appium at Scale - Mobile Grid workshop
Selenium Grid can be a bit daunting to get up and running. Starting it is quite easy, but using it effectively can require pulling in third-party tools. In this workshop we’ll cover how to run your grid effectively, using best practices culled from several large grid installations with a hybrid setup for both Selenium and Appium tests.
Jonathan Lipps / Daniel Graham / Kazuaki Matsuo - Fix a bug become a committer
Have you ever wondered how Appium works under the covers? Do you get frustrated with locators not locating, app screens not loading, or test behaving inconsistently from one run to the next? Appium is an attempt to unify thousands of disparate elements across a wide spectrum of challenges into a single, common interface that works seamlessly across all the major mobile and desktop OSs - and yet only a handful of volunteers work to maintain this gigantic effort. If you would like to enhance your own Appium experience while contributing back to the software that has defined so many of our careers, come to this workshop. We'll dissect the different elements of Appium, dive into its internals, learn how it was built and how to make changes to it, and even write a unit test you can contribute on the same day!
Fri, Jun 14
Registration - 30 mins
Jonathan Lipps - Appium: The Next Generation
Appium hit the open source stage almost 7 years ago and has gone through many iterations of development since then. In this talk, we'll look at how Appium continues to grow, and how the Appium devs are working to ensure Appium's relevance for the future.
The world of testing is rapidly changing. It's not just about functional correctness anymore: UX testing, performance testing, visual testing, and no doubt several other kinds of testing have descended upon us. Tools and methodologies have also proliferated—image analysis, AI, and other new terms give us pause. What will testing even be like in 5 years?
I don't know the future, but I know that Appium's philosophy and development methodology are well-suited to ensuring Appium adapts to whatever the testing ecosystem becomes, and I'll give examples both of how Appium itself is evolving to take advantage of new technologies, as well as how Appium's own ecosystem is growing (through a proliferation of Appium-related vendors and products). And of course, we'll save a bit of time for something … interesting.
Welcome Address - 20 mins
Coffee/Tea Break - 20 mins
Angie Jones - Your Tests Lack Vision: Adding Eyes to Your Automation Framework
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.
Sai Krishna / Srinivasan Sekar - Life Cycle of an Appium command
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.
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.
Bruno Alassia - Go beyond the software, automate hardware scenarios on Android Emulators
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.
Wim Selles - Building your own native app visual testing module with Appium
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
Sravan Kumar - Bootcamp to understand Appium android internals
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) and how the communication happens between Appium modules.
Vishvnath Pratap Singh / Lokesh Mittal - Automated Solution for Non Functional Requirements (NFR) & Performance Metrics Of Mobile App
Android/IOS Performance monitoring generally is to concentrate on numbers such as throughput, but evaluating key parameters can often be more revealing and valuable. System aspects like Memory profiling, CPU tracing & network utilization gives us app insights for defining app behavior good or bad, in terms of app performance with metrices like Memory usage,Cpu usage, Network data usage, Battery usage, Slow UI/frozen frames evalution ,Activity life cycle performance ,shared preferences usage etc.
App performance demands an early insight of capturing key metrics in development phase, to be dependent on production monitoring can be too late. This can help us tune to the desired level of business goal achievement as well.
LunchBreak - 60 mins
Anand Bagmar - Testing & Release strategy for Native Android & iOS Apps
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.)
Tomer Cohen - Low-level android automation with adb
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.
Gaurav Singh - How to kill test flake in Appium?
Whether you are a beginner learning the ways of writing UI automated tests or an experienced practitioner, you must have faced the below situation:
You write a test and it works perfectly in your local, happily you promote the tests to your CI environment and surely it passes initially, however after sometime the test starts failing sporadically. This phenomenon is described as Test flakiness and it’s a bummer for any engineer worth his salt. This can cause numerable side effects and doubts into the minds of software teams not trusting UI automation.
However all hope is not lost. We all know a Tool is only as good as its master.
In this talk, I will cover the measures or patterns which you can implement to reduce the flakiness in your Appium tests as much as "humanly" possible and increase their speed and reliability.
Jonah Stiennon - Find Elements By Accessibility Id
You'll find many written sources which assert that AccessibilityId is the preferred selector to use for finding elements, but why is this the case? What's wrong with XPath?
In this talk, we will discuss Accessibility Id's in depth. How Appium uses them to find elements on iOS, Android, and web, and how developers add these Id's to apps. We will specifically focus on the performance impact of using XPath selectors instead of Accessibility Id's.
We will demonstrate techniques we can use to improve the performance of XPath selectors if accessibility Id's are missing, and discuss strategies for convincing managers and app developers to add accessibility Id's to the apps we automate.
Aisyah Dzulqaidah - Cloud Based Mobile Application Testing with Appium
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.
Kazuaki Matsuo - Start contributing to OSS projects on your way
Through a story of my contribution to OSS projects, especially Appium, you can learn how you can start contributing to OSS world. I would also give some examples to start it.
Coffee Break - 25 mins
Anton Angelov - How to Test the Test Automation Framework?
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.
Daniel Graham - Unlocking New Testing Capabilities with Espresso Driver
Android's Espresso framework was created as a "gray-box" testing framework, "gray-box" meaning that it's an automated UI testing framework ("black-box") but it has access to the internals of the application ("white-box"). Allowing access to the internals of the application-under-test opens up many new testing possibilities that weren't possible with UiAutomator2 (with some risks).
Here are the four new possibilities I would like to discuss (with coding examples)
- Access to internal app code
- Less flakiness thanks to "IdlingResource". No need for 'waits' and 'delays' for UI.
- Navigate WebViews using Espresso WebAtoms (this feature is in progress, will be ready well before June)
- Find elements off-screen using Espresso's DataMatchers (this feature is in progress, will be ready well before June)
Raveendar Reddy Anugu / Rajesh Kumar - Automated Static and Dynamic Security Analysis of Mobile apps
This workshop will cover mobile application security testing techniques which comprises different security bypassing methods and automation of static and dynamic analysis of mobile apps.
Below are the some techniques and tools will use for demonstrating mobile application security.
- Root detection bypass
- SSL Pinning bypass
- Static Security Analysis(Manual and Automation)
- Dynamic Security Analysis using MobSF and Burpsuite
- Drozer - Intent bypass
- Use of APK analyzer and APK editor
- Miscellaneous vulnerabilities in Mobile applications
Pradeep Soundararajan - Building Tools to Free up Exploratory Testers
I have been a functional exploratory tester. I was motivated to move out of exploratory testing and go into automation. Thankfully, someone pulled me aside and told me - I am more suited to be a functional exploratory tester and I am business savvy. I didn't shy away from code. I worked closely with developers, my testing approach involved reading code (didn't write any) and brought in value to developers and to the business. I grew up as a tester being coached by experts, reading blogs from experts and learning that automation will help exploratory testers do more.
In my wait - I found very little effort that has gone in direction. I partnered with developers to be building some products.
I failed multiple times but here are my failed attempts
1. Tool for Social Media Driven Testing for Testers
2. Tool for mapping the heuristics and oracles to test ideas
3. A checklist tool for testing mobile apps and scoring on quality for start-ups
I would like to share
- The thinking behind building these tools and their value
- How purely focusing only on automation is taking away the possibility of building tools
- How I would love the community to start building tools
- How I can help and how they can help me
Rajdeep - There is more in Espresso Driver's Element than you think/ WhiteBox testing using Appium
Have you been in a situation when some cases are impossible to test because Appium doesn't have support? Appium is improving continuously and release of espresso-driver is an example of this.
Espresso driver opens up possibilities of white-box testing using Appium. One of which is the ability to call platform methods on elements via backdoor without modifying Application under test. What it means is, if the Android platform supports some actions or properties on an element, then Appium will support it out of the box.
For an automation engineer, that's a very powerful addition. I was fortunate enough to work on this feature and would like to showcase what are the various tricky cases where this feature can be applied. There will be real examples shown with a sample android app. I will also introduce one more small bonus feature at the end, about flashing elements on screen ;)
Dan Cuellar - Lightning Talks
Dan was selected to speak at Selenium Conference 2012 in London about an entirely different topic. As part of his presentation, he showed off iOS Automation using Selenium syntax to demonstrate writing platform-agnostic tests that use separate platform-specific page objects with a common interface. To his surprise, the cool test architecture would take a backseat to the spectacle of iOS tests running like WebDriver tests. Several people suggested that he give a lightning talk later in the conference to explain exactly how it worked.
On the second day of the conference, Dan stepped up on stage to give the lightning talk. Jason Huggins, co-creator of Selenium, moderated the lightning talks. Dan experienced technical difficulties getting his presentation to load, and Jason nearly had to move on to the next lightning talk. At the last moment, the screen turned on and Dan jumped into his presentation. He explained the details of his implementation and how it worked, begged for contributors, and in five minutes it was over. The crowd applauded politely, and he left the stage.
If we look at how Appium came into existence, lightning talks are a very important part of this journey. Hence at Appium Conf, we would like to dedicate a full session with all attendees on Lightning talk.
Birds of Feather (BoF) - 75 mins
Dinner and Networking - 150 mins
Sat, Jun 15
Registration - 15 mins
Jason Huggins - World Domination: Next Steps
Web browsers? Too easy. Mobile apps? Mildly amusing. It's time for the Appium project to get ambitious.
The new goal: Automating anything anywhere in the world. Cars, planes, watches, toasters — if it's got software inside, you'll use Appium to test it.
How will we do it? Attend this talk to find out!
Important Announcements - 20 mins
Coffee/Tea Break - 20 mins
Justin Ison - Appium Native Application Crawler
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
Vivek Upreti / Naresh Jain - Setting up Jenkins CI Pipeline using Appium tests for Android and iOS
GUI and functional tests determine if the product is working correctly from an end user perspective. With increasing number of automated GUI tests we would want to automate when and where they are executed. Continuous Integration helps in merging code to a centralised repository frequently and find out issues early in development cycle in order to help push quality upstream.
In the talk, you will see examples of how you can setup CI system for Android and IOS native/hybrid apps and how to plugin your Appium tests in the pipeline using Jenkins. We will also talk about the challenges we face while setting it up for Android and IOS applications. We will also talk about how to strengthen your CI pipeline via integrating various tests and Static code analysis tools.
Shama Ugale - Testing your Bot!
Chatbots are one of the most widely adopted AI/ML implementations in the business sector. A chatbot is an intelligent machine used to imitate human conversation through text and voice commands. Today bots are widely used as a personal assistant, customer service, HR, sales and marketing to name a few. In short, bots are everywhere and we rely on them to a certain extent, this makes it extremely important to assure the quality of the chatbots and test them thoroughly. They are built using NLU/NLP-Services (Natural language understanding and processing) and are subjected to constant training and improvement which has direct impact on tests. Voice based bots like Siri and Alexa depend on speech recognition technologies. As the chatbots user do not have any barriers and due to the unpredictable user’s behavior it becomes utmost difficult to verify the correctness on the output. In this talk, we will discuss how the chatbots are different as compared to the other applications and the challenges they bring onto the table while verifying their behavior, and focus on the testing strategies and automation testing of the bots.
Nozomi Ito - How we use Appium as our product's core library
Appium is very useful tool, but that does not mean everyone can use it without any effort.
Users sometimes need to tweak command parameters, and the version upgrade of Appium or dependent platform sometimes causes problems.
As the lead developer of a cloud testing service using Appium as its backend, I have been managing these problems with various measures.
In this session, I introduce especially unique ones of all these measures.
Diego Molina - Building a Mobile Testing Infrastructure: What I Learned
Mobile is everywhere, and everyone wants a piece of it. All companies want to have mobile apps for their products, lots developers want to code mobile apps, and lots testers want to build awesome tests and frameworks for mobile apps…
But, what about the infrastructure? Does someone want to spend endless days building a test infrastructure for Android and iOS apps? Not so many people have the time and patience to put all the pieces together and make them work like a Swiss watch. It just seems that many people forget that tests also need a solid infrastructure to be reliable.
In this talk, I will narrate the journey I went through while doing the job that not so many people want, building a mobile testing infrastructure. The attendants will see all the steps taken in the process of planning the system architecture, how all the components were selected, and how they were put together.
More importantly, I will share the lessons learned and the open source components that are being used in the final solution, and also guidelines on how to scope the needed resources when building your own mobile testing infrastructure.
Louloua Jawadwala / Reiaz Gafar - The Robots are Taking Our Jobs!! (But in a Good Way)
Shopkeep is a point of sale software company. We use Appium for testing our iOS and Android apps. One of the biggest limitations of our automation suite was that we were unable to test our hardware, including the credit card readers our mobile app interfaces with.
To overcome this limitation, we came up with a solution to create a simple robot and attach it to a web endpoint. Making simple HTTP post requests, our credit card swiping robot can now swipe cards on the credit card reader. After going through certain iterations in the development of this prototype, we are now creating robots for testing chip card insertion, as well as contactless/NFC based transactions.
This talk will cover the different components that this robot is made up of. We will also look at the challenges we faced and how we integrated this solution to our Appium automation suite. Our talk aims to inspire you to think of what real, physical objects you can test using a similar solution.
LunchBreak - 60 mins
Srinivasan Sekar / Sai Krishna - Native mobile commands in Appium
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.
Sargis Sargsyan - Run your Appium tests using Docker Android
In this high technology times, it is really hard to catch up with everything. Especially for the mobile world when there are thousands of mobile devices with different modification of the Android OS. Most of us who work in the mobile testing industry familiar with Appium framework for a UI automation and also aware of complicate setup and hard maintenance of it. Using Docker in Android UI automation is making our life much easier. Docker-Android is a docker image built to be used for everything related to Android mobile website or application testing. All the tools needed (devices, framework, Android SDK etc.) are packaged in the image. It is free and open source and supports other features such as video recording.
In this session, we will talk about the advantages and disadvantages of Appium and docker-android will go throw getting started with Docker-Android and run sample tests against it.
Christian Bromann - Appium for Couch Potatoes: An HbbTV Driver
Almost 13 years ago we started with Selenium to automate websites. With Appium we generalised that concept on mobile and just recently entered the Windows and Mac space by adding a Windows and Mac OS driver to the Appium family. Let’s continue our StarDriver quest and enter a (not quite) new sphere: the television. Within the last years, a new standard called Hybrid Broadcast Broadband TV (HbbTV) evolved with which the latest generation of Smart TVs has been equipped. This standard allows broadcasters to build web apps for their broadcast channels to provide additional context information to the TV stream or videos on demand.
This talk will introduce a new driver to Appium that allows the running of automated tests based on the Webdriver protocol for HbbTV apps on Smart TVs. It will explain not only how the driver works but also how in general other drivers do their job in the Selenium and Appium world. We will look into the challenges that automating an app for a TV device brings and will talk about how anyone can build a driver for anything.
Coffee Break - 30 mins
Jonah Stiennon - All Desired Capabilities
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.
Kazuaki Matsuo - Uncovering breaking changes behind UI on mobile applications
It is essential to track user logs correctly to improve and develop your own web/mobile services continuously. For instance, how users flow on your applications to evaluate if they work expectedly or not.
Meanwhile, mobile application trends have been changed quickly such as architectural things or UI related one. Developers continue to add, refactor or rewrite their applications frequently. They also need to release them frequently, 2-week release for instance. Their business also changes quickly. A number of developers working for one application also has been increasing.
As a result, it is quite difficult to catch up with everything. Developers know a part of them. They add, rewrite or refactor codebase they do not know well with exploratory it. Functionalities related to UI are easy to understand. But, it is difficult to uncover what happens in the backend such as what kind of logs the app sends to servers.
In Android case, if one application sends a log to a server on a fragment's onCreate. But the fragment can use in another view. If a developer does not know what the log means, he/she might re-use the fragment in another view if he/she think they can re-use it. It can break activity logs collecting on the server side. How to maintain logs is also an interesting topic though.
In general, we notice the breaking after releasing the app since we can easy to observe the number statistically. But, it means we can not use the data to evaluate our business correctly until we fix it and re-release it.
In this talk, I would like to show an example of how I had been implemented to uncover the above thing following some scenarios based on my experience. It might be an example what we already can automate in the mobile world.
This topic is similar to monitor CPU/Memory/network thing. This story is based on my experience I had been worked for a couple of years.
Dawid Pacia - Mobile & IoT integration testing - "Mission Impossible" or "A last hope"?
It is predicted that till 2025 there will be over 75 billion devices spewing 180 zettabytes of data and generating up to 6 trillion dollars. That enormous increase force companies to introduce a continuous approach to deliver the product as fast as possible and be able to compete on the market.
The main question is how to test application for end user among so much hardware equipment and ecosystems combining HW, FW, mobile devices and complex backend architecture? Considering all factors and possible obstacles is it for companies a real “A New Hope” for companies or just simply “Mission Impossible”?
I will take the participants on a journey to the IoT world. It will be a talk about the challenges that any tester will face at some point. I will present the dangers, risks and snares but also good practices and practical approach to mobile E2E test automation for the IoT solutions in CI approach.
Technical examples will be presented using Python languages and supported by physical devices (mobile phones and IoT equipment).
Simon Granger - How we took Appium to 11 platforms
Every second, a million minutes (17,000 hours) of video content will cross global IP networks by 2021, according to Cisco (via Forbes). As it stands today, over ⅓ of online activity is spent watching video. However, there is a unique challenge testing video applications because they tend to run on a wide range of platforms - mobile and tablet, streaming devices, consoles, and Smart TVs. Today, it also demands on individually testing the app on each and every device - highly inefficient and a real pain.
At You.i TV we have developed an Appium Driver that allows us to use the power of Appium to test C++ and React Native video applications on a wide range of platforms including iOS, Android, tvOS, Android TV, PS4, XBox One and Samsung Tizen simultaneously - an industry first.
This talk will focus on the journey and learnings we discovered along the way - including writing a custom Appium Driver, the unique needs of 10-foot devices (remote controlled), and the power we see in combining Appium with React Native.
Bijoya Chatterjee - Trust Issues with UI Automation
UI Test Automation is notorious for stability issues. UI automation is almost synonymous with "Flaky Test". We discuss taking a proactive strategy towards test automation flakiness as opposed to a reactive approach where we look at failures and then decide the course of action. How can we in the test automation community use and develop tools that helps eliminate flakiness and also identifies flaky tests before they are not just run but even before they are merged. How do we create these tools in a service model that plugs into our Continuous Integration pipelines ?
Dan Cuellar / Naresh Jain - Q&A with the Appium Committee [Panel]