0:06Hi, and welcome to today & # x27; s webinar on Automate Everything, Appium 2.0 and New Drivers. My gens is Jason here at Headspin, and we & # x27; re thrilled to have you join us today. We & # x27; re excite to have Jonathan Lipps backward with us again. For those who don & # x27; t know Jonathan - Jonathan is the Architect and Project Lead for Appium, the democratic open-source automation framework, and is also the founding principle of CloudGrey, the consulting firm helping customers successfully leverage the power of Appium and the source of Appiumpro.com.

We need this webinar to be synergistic. So, if you hold questions any clip during the session, please type them into the question box in your gotowebinar control panel. We ’ ll have some clip to address them at the end. Last but not least, this session will be recorded and sent to all attendee. So look out for the email. So, without further ado, I will turn it over to you Jon.

Thanks a lot Jason, and Good dawning everyone, or good afternoon, or eve, or midnight, count on where you might be in the world. I ’ m really excited to be here in what is my morning, talking about Appium drivers and Appium 2.0. So, Jason already gave a really complete introduction for me, so I ’ ll just add this painting. I ’ m even bear the same hat today. This is, in fact, what I look like, and I do work on Appium, both the open-source side as well as help my clients be successful with and nomadic automation.

So, today we ’ re depart to have a brief introduction and tour of four driver which are part of the Appium driver bucket that you might not have used before. We ’ re going to talk about the Espresso driver, the Windows Driver, the macOS driver, and the Raspberry Pi driver, which is for testing IoT device. That ’ s definitely the most out-there of all we ’ re travel to look at.

And of course, we will too touch on Appium 2.0. I ’ ve be act on Appium 2.0 a small bit, and I opine it was time to start distribute my ideas about what Appium 2.0 is, what ’ s the vision, and what are some of the technical theory and changes that you might expect when it ’ s released sometime future year.

So initiative of all, let ’ s drive a little bit beyond mobile. Let ’ s go beyond the distinctive Android and iOS drivers that you probably use with Appium and verbalise about some of the other possibilities. The basic idea here is that Appium uses something called the Webdriver protocol to facilitate the communication between your examination handwriting and the Appium server, which then ultimately performs the automation commands that want to happen.

The Webdriver protocol

The Webdriver protocol, as you can tell in the name, was primitively designed for automate web browsers. And, you know, it ’ s already the case that Appium utilise this same protocol to automate mobile applications. We simply pass it in a few ways and added some extra capability, but by and large, if you seem at an Appium test script, it looks and reads very similar to a Selenium tryout hand.

So the question is: why not go farther? Why not go beyond mobile to other types of applications? When you get flop down to it, applications are pretty much the same regardless of the platform, whether an app is running in a web browser or mobile gimmick or on a background or laptop calculator. They pretty much work the same way.

So, that is in fact, what Appium has make with some of these not so well-known driver. We ’ ve run the Webdriver protocol to indorse many early platforms, including desktop coating. The really nice lineament of this capableness of Appium is that you can write your test scripts in any lyric, mix and match them with any fabric, and that will target pretty much any platform that ’ s out there.

Whereas, of line, if you wanted to automatise Mac outside of Appium, you would be looking at wad together your own system events approachability scripts and things like this, which would work, but then they ’ re not move to have anything in common with scripts that you might already get for the web variant of your app or the nomadic variant of your app. So you get to leverage a lot of knowledge, a lot of code, and a lot of framework base and reuse all of that stuff when you trust on Appium as your automation fabric. So, that ’ s constituent of Appium ’ s vision. So, let ’ s look at some of these driver and what they can do.

Espresso Driver

First of all, let ’ s talking about the Espresso driver. Now, Espresso is the up-to-the-minute Android mechanization framework from Google. It ’ s not really new anymore.

It ’ s be out for years now, but it is the recommended approach for automation of Android application from Google. So if you ’ re only an Android developer apply Android studio, and just reading the Google developer documentation, you ’ ll see a lot about Espresso and habituate Espresso to automate your app for testing purposes.

Key thing to see about Espresso. First of all, Espressorelies on a gray box examine poserrather than the black box test framework that Appium usually utilise with all of its other platforms.

So, the difference hither is that a black box testing model means the mechanisation comes in from the exterior, treating the coating as a black box, and it can exclusively do those sorts of things with the application that a user can do like: tapping on elements or reading things off the blind to get info about the province of the covering. It doesn ’ t have access to the application internals. Now, in gray box testing or white box testing, coating internals are available to the tryout script. So, the test script is running in a context where it has access to the application source code and can therefore trigger different bid or get different information about the province of the application from inside of the covering itself.

It ’ s like being able to look a little bit into the application and do some things there. Another great lineament of Espresso is what ’ s telephoneidle synchronization– and this helps to speak a huge problem in any variety of UI automation – which is that the automation is often trying to do things when the UI is not really in a resting state.

So, if you ’ ve ever encountered element-not-found exceptions, it ’ s probably because your examination codification made an assumption about the state of the application and the application hadn ’ t painted that survey yet or hadn ’ t navigated to that webpage yet. In former words, the application was doing something when you tried to interact with it, and it wasn ’ t ready. And, a human user use their optic and their brain to notice when an application is do something, either there ’ s a spinster or maybe in a browser the little loading procession bar is still depart across the top of the page, or maybe they ’ re looking for a specific element, and it ’ s not there yet, so they ’ re just waiting for it to show up.

What Espresso does is it really find when the application is in the middle of doing something, so that it knows that the application isn ’ t rather ready for user interaction. So if you post in a command to Espresso while it ’ s wait, it just kind of keeps that require and doesn ’ t execute it until it ’ s really ready. So this helps add stability and robustness to test, because they don ’ t experience the same form of flaky errors due to the app province not being what you expect. There ’ s some complexness hither, and Espresso doesn ’ t know about all the different way that your app could be busy. So, sometimes you have to instruct it when your app is busy so that we can take advantage of this idle synchronizing, but it ’ s a nice characteristic.

One of the other takeaways for Espresso is that because it is tied in with the covering itself,it is isolated to the app under test. So, you can ’ t use Espresso to automate all aspects of the device UI, the home screen and things like that. For that you would need to use the existing UIAutomator2 driver, which act by automating the approachability layer of the device which is kind of a layer that sit above all the applications. So it ’ s not tied to any specific covering. With Espresso, we also haveadmission to some advanced style of get ahold of constituent. We can yet find elements that haven ’ t show up on the blind yet, if they ’ re constituent of a data set that is bound to, for example, a data grid or a list view of some kind.

We can also chance elements by a survey tag, which is an Android specific part of info about elements that can be added by developer. This is peculiarly helpful for React Native, because React Native lay the test IDs into the position tag on Android. And, right now the Espresso driver is the solitary Appium driver that really afford you access to the vista tag of an element.

If you want to use the Espresso driver, these are the kinds of capabilities you need to worry about. Basically, it ’ s just like any other variety of Android automation capacity with Appium, except for you need to make the automation name equal to Espresso.

On this screen, we have an exemplar of a dictation which is but available on the Espresso driver. If you look form of in the eye of the blind here, we feature something that say “ driver.executeScript ” and we ’ re action this Appium script “ mobile: backdoor. ”

This is the backdoor method which enables us to get inside of our application codification and call methods internal to our application that a exploiter would never see from the outside. So this is kind of what I was speak about early with the gray-headed box prove model. This is how Appium yield you access to this gray box aspect of Espresso.

In this suit, to forecast out what we ’ re try to do in the application, we can take a look at the scriptArgs variable hither, which is essentially just a big map of maps and we ’ re basically saying: “ we want to telephone a method that subsist on the application. The method ’ name is called raiseToast. ” If that ’ s appropriately name it ’ s going to show some message on the screen. And, the argument that we are passing to this method is a twine and it has the value “ Hello, from the test script! ”

If you look down at the real bottom line, you ’ d see what we would write in Java if we be writing code inside of the covering that leverage this raiseToast method. We ’ d fundamentally be calling the raiseToast method on the main covering Java class and would be ring it with this string statement.

The scriptArgs variable above is just our way of encoding all the information as a way to pass it to Appium, so that it can then call it within the Espresso context. I ’ ll how you a picture of what it looks like when that code is executed.

You can see it happened really quickly, but we saw this “ Hello, from the trial script! ” content pop up. Let me see if I can show you this again. My app real quickly pops up and then we get this message: “ Hello, from the tryout script! ” That was not triggered by any kind of UI interaction; it was triggered by directly calling that method internal to the covering habituate the Espresso driver.

If you require to learn more about the Espresso driver, I have an article about it – specifically this back doorway method –here.

Windows Driver

Okay, let ’ s talking about the Windows Driver. The Windows Driver is pretty awesome in that it ’ s actually powered by a puppet supply by Microsoft itself. So, Microsoft decided to build an Appium-compatible mechanization creature. They call it WinAppDriver. So, the Appium Windows Driver is fundamentally just a very small-scale span to WinAppDriver, which is maintained by Microsoft. Actually, it ’ s up on GitHub, so you can go and check it out and ask for improvements if you want.

Some key things to understand about the Windows Driver. First of all, itrequires developer style to be turned onthe machine or for your exploiter as you ’ re logged in. It besidesrequires Appium to be run in a console which has organization privileges. You necessitate to do the whole trick where you hold down command or option as you type in the command prompt in the windows start menu. You want to create sure that whatever you ’ re scat Appium in – whether that ’ s the typical command prompt or Powershell or some kind of bash equivalent on Windows, you postulate to make sure it has admin privileges.

The way thatyou launch coating with the Windows Driver is by an application ID. Usually with Appium you legislate a route to the application on disk, but this doesn ’ t work for the Windows Driver. Instead, every covering that ’ s instal and registered with the system has a particular ID, and these IDs can look pretty brainsick. They & # x27; re kind of unique ID-type things.

I found this command you can run in PowerShell called ‘ get-Startapps ’ and it will list all of the apps that are available and each of their IDs. If you want to automatize a particular application from this command and so look ahead in the list, you can get its ID. As far as I cognize these IDs, especially for Windows application, are the same across all Windows installs. It ’ s not like they disagree from computer to computer, but they ’ re unique in the world of Windows applications.

The other thing to be aware of with automate Windows applications is that apps don ’ t have an accessibility ID on Windows. But, Microsoft implemented this property ring“ AutomationId ”, which is specifically for AppDriver and other automation tools.

It ’ s pretty nice that they built this in. If you get your page source from a Windows application, you look through it, and you see an dimension labeled “ AutomationID ”, you can notice the element with that attribute use Appium ’ s accessibilityID command so driver.findElement by mobile by accessibilityID and so on. That ’ s how you would use that.

For the Windows Driver, the capabilities look something like this: platform name Windows, program adaptation 10.

This lonesome works on Windows 10. Although, it can automatise Windows apps, which are quite old, I think it has to run on a comparatively new machine. Device name is Windows PC, and so hither ’ s an example of an app. In this suit, it ’ s the conditions app that comes with Windows 10, and this was the ID that I launch utilise the get-StartApps command. This is what a trial could look like of the conditions coating on a Windows machine.

You can see it looks basically same any other Appium test. We ’ re detect some things by accessibility ID some other things by XPath. This particular test is trying to observe the different days which are exhibit in the conditions application and get some information about each of the days. For example, the sunrise and the sunset of that particular day, and when we run this example, it prints it out to the console.

So it & # x27; s kind of a way of, you could think of this as like RPA for Windows, let some conditions information from the conditions app. Obviously, there are more efficient ways to get weather data. We could use an API, but this is a fun demonstration of Windows mechanisation. This is what it look like when it ’ s running.

We actually tap through each of these different days, and then you can see sunrise is downwards in the day details. So, that ’ s what we ’ re scraping off as we tap through each of these different days. If you desire to learn more about Windows Automation and get the entire code for automating that conditions app on Windows, check outAppium Pro Edition 81.

MacOS Driver

Okay, let ’ s motion on to the MacOS Driver. The Mac Driver, as we name it, relies on the scheme accessibility frameworks to yield control over the full desktop. MacOS comes with system case framework that allows applications to fundamentally see everything that ’ s on the screen, to interact by moving the mouse or by snap on different things. It ’ s a very knock-down sort of automation.

However, the downside is that apps hold to be specifically given the permissions to control the estimator in this way. This is really good for security use. You don ’ t want random application controlling your figurer without your knowledge, but it does intend that there ’ s some manual apparatus that ’ s ask to make certain that Appium has the ability to automatise the system in this way.

Key thing to understand about the Mac driver. First of all, there is an genuine Mac application, a .app that runs on a Mac calledAppiumForMac, and this has to be manually download and establish and put into your applications folder.

Appium For Mac must likewise be granted accessibility control over the system, and it ’ s actually not just AppiumForMac that has to be grant accessibility control, but whoever is the kind of parent process of AppiumForMac. So, if you ’ re running Appium from the terminal covering and you ’ re scat a Mac exam that Appium will be bunk inside the terminal, and it will attempt to start AppiumForMac as a subprocess. The parent process of AppiumForMac is the terminal. That means you have to yield the terminal accessibility control over the scheme.

This is something you may not desire to do on your own machine for protection reasons, or you might need to turn it off. Because if the end has accessibility control over your system, then you could imagine if somebody tricks you into pass a malicious script in your terminal outside of your knowledge, something might happen on your machine.

It ’ s important to study your device under tryout to be something freestanding from your development and trial development workstation.

Pro tip: Tools like SUSA can handle this autonomously — upload your app and get results without writing a single test script.

You probably want to have a separate Mac Mini consist around or use Mac Stadium or something like this in order to run an Appium Test. And, then you might not care so much what pass on that system or you can find ways to ensure that malicious things don ’ t occur using networking protocols or keeping it internal to your local office mesh or things like that.

Okay, so the way that you open and launch applications with the Mac driver is simply usingdriver.get ()so rather of redact a URL for a web browser, we ’ re lay the name of an application. If I say driver.get (‘ Calculator ’) it will look for calculator.app in my application folder. So that ’ s pretty uncomplicated.

One other crease about the Mac driver is that there ’ s solely one locator strategy which is XPath. While in your tryout codification, you ’ ll be write things like driver.FindElement (By.XPath ()), the existent flavor of XPath, which is use by the Mac Driver is something callAbsolute XPath, or AXPath or XPath without any relative knob or queries or searches.

Every XPath interrogation must be fully qualified. I ’ ll show you an example of what this looks like. What this signify is that the picker for different elements can be rather long and quite tedious, and in some cases potentially quite brittle.

You get to do some imaginative thinking to do sure that your XPath locators are going to be robust. To forecast out what the locator of an element is: there ’ s a special characteristic that AppiumForMac has, where if you receive it loaded, you can put a mouse pointer over any element on the MacOS desktop or operating system or former covering and make down the function key for a few sec. Itcopies the XPath for that particular componentto the clipboard.

Capabilities for this driver are pretty straightforward. Platform and device name should both be Mac, and if you desire an app to start automatically, you can just put its gens as the app capability.

Here ’ s what a sample test looks like for the Mac driver. I ’ m testing the activity proctor application in this particular example, so you can see that I have a bunch of strings here where I ’ m defining XPath selectors by establish them up from a basal accessibility or absolute XPath.

The fundament Xpath, in this example, is AXApplication/AXTitle=Activity Monitor/AXWindow. And, the AXTitle=ActivityMonitor portion is extremely important, because that is what ensures that all of my other picker, which I build off of this variety of bass twine, that ’ s what ensures that they all take spot within my application and not within some other application.

Then I ’ ve got something called a tabSelectorTemplate, which helps me to select different tabs in the coating, so the different chit like: memory, energy, disk, meshwork, or CPU. You can see again how I ’ m using this XPath filter, making sure that the accessibility title of that peculiar tab is memory, or energy, or disk, or network, or CPU. This is a somewhat reliable and robust way of finding these ingredient, time and time again, without swear completely on their position within the application.

All I ’ m make in this slight test is tap through the assorted bits of the activity monitor application. Eventually, I am type something into a lookup field and then getting the text of that search battleground and asserting that is what I ultimately typecast into it. So, it doesn ’ t really do anything particularly utilitarian, but you could see how you could potentially automate applications in a utile way using these command.

Here ’ s an example. Tab through all the different aspects of the activity monitor and then typecast into the hunting battleground. This was us controlling a Mac application using Appium. If you want to learn more about this, check out Appium Pro ’ sEdition 52.

Raspberry Pi Driver

Okay, let ’ s motion on to our last driver of the day: the RaspberryPi Driver. So, this is a special one. The idea behind this driver, and other alike drivers, is that application don ’ t actually incessantly have user interface. What about IoT devices?

These are physical things that lead some kind of sensational stimulant, whether it ’ s electric or pressure or temperature or wet or anything like that, and use that input to send data to something online or contain something in your house using a feedback system. So, these are not traditional devices with user interface. But, of course, they could still be screen and they could still be tested in automatic manner. So, why not use Appium to do this?

This was the experiment that I tried to do for myself when I was developing my presentation for Appium league earlier this year in Bengaluru and India. I took this a circuit playground express from Adafruit Industries.

This is essentially a little hackable circuit board that has a bunch of sensors build into it and can do different things like turn on or off a light or output some sound. I opine: “ okey, I want to figure out how to test IoT devices with Appium, but first of all, I need to have an IoT gimmick tryout. So I need to build some sort of IoT device to begin with. ”

So, I built this small drum machine. When I tap those different push, the light change on the circuit playground express. Also, you can ’ t hear it on the webinar, but some sound is emit from the headphone laborer. Actually, it ’ s not a jack. It ’ s one of these little electronic paths that we can connect a headphone to with some wires and things like that. A little drum sampling is played when I hit each of these buttons. I ’ ve got a kick, a snare, a hi-hat, and a tom that are attached to each of these different buttons. It ’ s a little drum machine that I developed.

Then I enquire myself: “ okay, I ’ ve got a drum machine. Now how would I want to examine this? ” There are a bunch of means to think about essay this. There ’ s software running on the circuit board, which I wrote, that I could just write some other software that would send the same commands as the real package does, whenever it look for someone to tap the button.

That would be kind of like one layer of testing, but I wanted to go a layer more existent. What I what I conceive is that each of these buttons works by changing the electrical signal that is proceed into the circuit playground board. Whenever I tap one of the buttons, with this exceptional designing, is that a circuit is broken and the circuit playground express software is listening for that tour to be separate. And, when it ’ s broken it emits the appropriate sound and changes the light.

I thought, ” I don ’ t need to physically tap a button to make this happen, I could just mail electrical sign into the same point on the circuit board. Whether that signal count as a high or a low signaling will then cause the circuit playground software to believe that a button has been pressed. ” This is like a functional approach to testing a tour plank sending in or removing real electric signals from the physical ports on this board.

So to do that, I got something call a Raspberry Pi. A Raspberry Pi is a little computer that ’ s only printed on a circuit board. It ’ s pretty awesome. I recommend play around with them. The important part about this Raspberry Pi is it has something call the GPIO heading. It ’ s up at the top hither. It ’ s in two different rows of fall and GPIO stands for “ general purpose input output ”.

These are pins that the Raspberry Pi can use to post electrical signals through. What I need to do was take this Raspberry Pi and connect wires from the little peg here to the port on the tour playground tour board. Then have the ability to send electrical signals from the Raspberry Pi mimicking me pressing one of the drum machines ’ buttons physically in reality.

What I was capable to do so is acquire an Appium Driver for the Raspberry Pi that lets me write an Appium test to say when these different pin on the Raspberry Pi should emit or stop emitting electric signal. By doing that I was capable to build an Appium test script that drove the circuit playground IoT application of a tympan machine without actually having to tap the drum button themselves, but also without bemock the connectedness. I ’ m still post electrical signaling the exact same way that tapping the button would.

Let ’ s see a small bit what this seem like. This is the script that I compose to play a little song. You can see I ’ m actually but using a JavaScript driver hither. I ’ m attaching to an Appium waiter running on the Raspberry Pi itself, and I ’ ve got all these helper methods for you know, playing a song based on which pin are associated with which tympan sounds. In this case, I ’ m finding component by ID.

These are the elements that jibe to the different I/O port on the tour playground express circuit board, and I ’ m making electrical signals either go into or not go into those ports by using the sendkeys dictation. I can send a O which means no signal or I can direct a 1 which means signal.

That ’ s how this work. Let ’ s see. Now what ’ s happening in the other terminal window. I ’ m starting up the Appium server on the Raspberry Pi itself.

And, here ’ s a picture of how it ’ s all connected. I ’ ve got the wire coming out of the Raspberry Pi connected on top of the other wires arrive from the buttons because I ’ m not qualify my app under test, and now I ’ m running my trial script.

You can see that as the commands are being called, the different drum lights are being activated. We can ’ t hear it, but the different drum sounds are being emitted as easily. So that was how we ran an Appium test of an IoT gimmick using electrical signals, a Raspberry Pi, without modifying the drum machine device under test. That was pretty fun.

Key things to understand for this Raspberry Pi driver isit ’ s not an official driver yet.It essentially runs in standalone mode. Itruns on the Raspberry Pi itself. So you have to install an operating system on the Raspberry Pi and clone and build this driver in “ node.js ”. You have to hold “ node.js ” instal as well.

The idea of an app is a bit different in that there ’ s no software application, alternatively what we ’ re doing is delimitate a set of electrical inputs and outputs. So theapp capacity is actually simply a JSON object, which defines which pins have which namesand what their initial states should be – whether they should be high or low.

Then we canuse driver to find element by ID, a pin bythe name that we gave it in the app potentiality, and then all we do is wepost a 0 or 1 to that pin apply sendkeys to set the state of the PIN to low or high. So, it ’ s pretty mere. There ’ s not a whole lot you can do with electric signals like this.

If you need to read the full scoop on this, I ’ ve got two edition on Appium Pro start atnumber 74.

Appium 2.0

Okay. Now let us wrap up by discussing Appium 2.0, and so we can lead some questions. The thought behind Appium 2.0 in my psyche – the big picture is that Appium proceed from go a tool and automation library to becoming a program for a whole mechanization ecosystem that spans devices and platforms and frameworks and everything else.

So, the thought is that travel forward, Appium itself is going to be this one small piece of the mystifier and so we ’ ll have many different drivers and many different plugins – all of which have their own independent world and ontogeny trajectories and everything else, but they are integrated with Appium as and when you need them to be. So they ’ re not all bundled together into one big package the way that they are now.

So, with Appium 2.0, we ’ ll have a unscathed new set of command line instructions you can run. For representative, you ’ ll have the set of Appium driver commands. So you ’ ll be able to name which drivers are installed or available to establish.You ’ ll be able to install a specific driverfrom the standard repository or from anywhere on npm, or anyplace on GitHub, or anyplace on your local file scheme.

You ’ ll be able to uninstall drivers. You ’ ll be capable to update them. So, you ’ ll be able to direct just one driver, just the XCUI exam driver, and say: okay Appium, update this driver to the latest for me, but the UIAutomator2 driver, I like it how it is. You cognise, I don ’ t want to advance to the next version of that, because it has some break changes, and I ’ m not ready for them. So just update this one driver for me.

The idea here is that Appium ’ s different drivers are for completely unrelated platforms. They have completely unrelated ontogeny round and different engineering that are used in their development.

They shouldn ’ t really be bunch together in a way which combines a certain version of the XCUI test driver with a sure version of the UIAutomator 2 driver the way it is now on Appium, because those are just unrelated things. So they should be able to change with respect to one another. We also will hold a dictation to verify your driver manifest to do sure that all the drivers that Appium thinks are installed are actually establish and so on.

Let ’ s talk a little bit more about the new driver framework for Appium 2.0. The basic idea hither is that not just the Appium squad, butanybody can make and release a driver that anybody else can use. So flop now, if you want to create a driver for your squad to use you can do that, but you have to modify Appium Source codification to get it punch in, or you have to convince the Appium team that your driver is utile plenty to be considered one of the criterion drivers that ’ s a part of Appium. So the Appium squad has been paw importing and coding connector to those driver into the Appium source code, and that ’ s not going to happen in the futurity.

Instead, the Appium team will just preserve a list of supported drivers and what their names are. So, the official drivers will just be a list that everybody will be capable to establish by name, but that doesn & # x27; t keep you from installing anything else - any unsupported or unofficial driver as easily. So as I aver before, any driver that you make would also be installable from npm, from GitHub, from any other git repository you get access to, or still the local file system. If you just have a driver that you & # x27; re playing with or that you & # x27; re distributing as tar balls around your team or something like that.

39:59 Also, as I said earlier drivers will have their own main versioning unrelated to Appium versioning. So, the main drivers right now are version individually. So, XCUI test driver has its own adaptation and UIAutomator2 driver has its own adaptation. But, when we release a new version of Appium, one exceptional version of each of those drivers are bundled in, and that & # x27; s what you get when you install Appium. And, this is not what we want to happen.

So that & # x27; s why Appium itself will not come with any driver by default. So whenever you install Appium, the next thing you & # x27; ll do is Appium driver install, XCUI examination, and then you & # x27; ll get that driver, and if you need more you can install more. But that & # x27; s the canonic idea.

40:45 In addition to drivers, Appium 2.0 will besides have the concept of plugins. I & # x27; ll say a slight bit about plugins here in a moment, but they & # x27; ll basically have all of the same commands available as driver do, so anybody will be able to publish and publish plugins that will be installable using Appium plug-in install and friends.

So what are plugins? Plugins fundamentally let you add arbitrary functionality before and/or after Appium Commands. So if you think about the findElement command you could indite a plug-in that when the findElement command come into Appium, instead of mail that bidding on to the typical driver, you do something else with it.

41:33 So for example, a plug-in that I evolve a spell back allow you to search for an element by a semantic label and then a machine learning model is employed to picture out which elements might match that label ground on their appearance. So this would be an example of a plug-in that would just form of pay attention to the findElement command and add additional functionality before or after that command.

Plugins can also modify the Appium server itself. So if you have an thought for a totally new commands that you would like Appium to have and you want to write a little guest to access those commands that you distribute among your team. You can besides add routes and handler to Appium itself.

42:42 As I mentioned before, plugins will be distributable and insoluble and all the same ways as drivers are. So, if you have it up on GitHub anybody will be able to install, or if you have it up on npm, anybody will be capable to install it. So basically you can think around plugins as tiny pieces of functionality, which can be small or they can be large, but they can be share with others and you can mix and tally them with a variety of other plug-in.

So you can select which plugins are active at any afford point in time in your Appium Install. Of trend, just like driver, plugins require will need to implement a very specific interface that Appium document in order for them to be compatible with Appium. And, there & # x27; s a lot more to think through with plugins. This is still very former days.

43:11 So once we actually have a beta out, I sure trust that a lot of people will jump on the opportunity to develop plugins so we can figure out what & # x27; s not working, whether there are any protection concerns we need to be vex about, whether there are extra eccentric of plugins or plugin feature that need to be enabled in the plug-in interface to help people build what they need to build. There ’ s a lot that needs to be work on, but this in my judgment is one of the most exciting things get up in Appium 2.0.

43:43 Of line since it & # x27; s the first time we & # x27; ll have bumped Appium ’ s major version in seven or five or six eld. I can & # x27; t remember. I think it was 2014 when we liberate Appium 1.0. So yeah, it & # x27; ll be five or six geezerhood.

We & # x27; ll likewise squeezing in any breaking changes that we involve to. It will be easy to get breaking change in the future and also respect semantic versioning because each of the different driver that the Appium team maintains will be on their complete own versioning dodge so we can upgrade the XCUI trial driver from version 2 to version 3 without worrying that it will draw in break changes for people installing the next patch adaptation of Appium or something like that. So breaking change will be insulate to the special drivers or plugins or server that they correspond to and won & # x27; t kind of wetting into citizenry using them from other projects.

44:48 So I & # x27; ll give you a little demonstration of Appium 2.0. I don & # x27; t experience a whole lot already done in it, but I & # x27; ll show you what there is. So. I & # x27; m in my Appium development directory. So instead of typing Appium. I & # x27; m locomote to type node dot to actually trigger the code here.

So first thing I & # x27; ll do is I & # x27; ll run driver list, and that will establish me all the available drivers. So, I actually don & # x27; t have any usable drivers flop installed right now, so if I only start Appium, I get this message “ No drivers experience been install. Use the ‘ appium driver ’ command to install the ones you want to use. ” Okay. Well, that & # x27; s what I & # x27; ll do.

45:29 So, first thing I & # x27; m move to do is install one of the driver that were listed as available. So I & # x27; m going to install the UIAutomator2 driver. So, hither Appium will undertake to find it and it & # x27; s installing it mutely here under the punk using npm. So this occupy a instant based on my web, and of course with npm, there ’ s lots of files to download and unpack.

I was rattling proud of this little loading animation with the dot here. Inordinately majestic. I & # x27; m locomote to make it nyan cat at some point here.

46:12 Okay, so it says driver UIAutomator2 successfully installed at this particular version and now it yield me the UI mechanisation name, or sorry, the automation gens that I require to use in my capabilities to trigger this driver to be used for a particular session, and it also give me the platform names that this driver indorse, which of class is just Android. So now if I run the Appium waiter, I get a substance that I get exactly one driver available and it tells me what it & # x27; s automation name is.

46:42 So I can also install drivers from their name. So that would be one of the Appium officially indorse drivers.

Oops, run driver list to show you again that the UIAutomator 2 driver has be installed. Another driver is not yet installed.

47:08 So, what I & # x27; ll next do is establish a driver from GitHub. So, I know that I have the Safari driver. I & # x27; ll say “ driver install -- source=github=GitHub ” and then I & # x27; ll but put in the GitHub organization and project name here: appium/appium-safari-driver. This is a driver for Safari on Mac, and it & # x27; s attempting to find it, and it since now installing it from GitHub.

So again, this will take a small bit of time. Okay. Now, we have these Safari driver successfully establish, and you can see that it actually potentially has multiple platforms that it supports. So if I again, listing, I can even exactly lean the ones that are installed.

48:05 And, there it is. And, we see that it & # x27; s hard driver was actually cloned from this GitHub URL instead of installed via NPM. So, this is all that I can really demonstrate right now. Basically all I & # x27; ve got kind of work in a demo of a mode is this driver management scheme. If you & # x27; re wonder how make Appium keep track of these different drivers. Well it now creates a kind of Appium domicile directory which defaults to “ .appium ” in your abode directory.

And, inside there & # x27; s something called “ drivers.yaml ”, so we can take a looking at this, and we can see that this is the little file that Appium has created that has a list of all the drivers that are installed and where they were installed from and their variation and things like this. So this assist with the management of Appium.

48:57 So you could ideate that if you have an Appium set-up that you & # x27; d like to replicate on dozens of different machines, you could set it up on one machine, take the “ driver.yaml ” file, make sure that it gets in the right place on all the different machine you want to install Appium on, and then just have Appium kind of rehydrate the establish drivers based on that yellow bundle. And of line, plugins will also be define here as well. So it & # x27; ll be a nice way to kind of experience your Appium configuration in code rather than in a set of commands that you need to run as well.

Q&A

Q: So basically, you don ’ t need to use explicit waits for Espresso?

A: Yeah, great question. I entail that & # x27; s basically the idea. In a lot of cases, I found that to be true. There are some cases where Espresso doesn & # x27; t really know that your app is doing something. By nonremittal, it know of you as transitioning to another view. I think yet maybe if a web petition is befall, it decides that the application is in the eye of something. But some cases it might not cognise that your coating is in the middle of something. So, in those cases, I & # x27; ve nonetheless seen a few examples where it & # x27; s safe to use an explicit waits, but I typically just write my test without explicit hold and then see if something breaks.

There ’ s also, in the case where something faulting, I then add an expressed wait around it. There & # x27; s also the power to really write custom Java code that will teach Espresso about your application and have your covering let Espresso know when it & # x27; s execute something. So, that is still possible to do. It & # x27; s precisely not part of Appium itself. It & # x27; s something you have to do in your source code.

51:54

Q: Can I run the backdoor Espresso characteristic on any APK resident on an Android device even if I have no direct access to the source? I & # x27; m thinking about various preload APKs that are apart of the OS.

A:Yeah, outstanding question. Unfortunately, I don ’ t believe this is possible. The reason is that you experience to have a debug APK so it can & # x27; t be just an APK that & # x27; s already on the device or download from the app memory. It has to be one that you construct in debug mode, differently Espresso will not be capable to automate it. This is one of the downsides. It & # x27; s kind of like the power that you get of looking inside the application is also a really big security risk. So, Espresso only allows you to do it to application that you get debug approach over. Whereas the former driver, the UIAutomator2 driver, can & # x27; t look inside the application. It basically can do what a user can do, so there is no security fear. So it has basically full availability admittance over all of the coating and aspects of the twist.

Q: For IoT, is there a gray box testing available in addition to the white box ETL testing?.

A:I wouldn & # x27; t call GPIO white-box testing, to be dependable. I would say that white box testing would be like, if I took my drum kit software and I created test code that precisely lived inside of my drum kit software and trigger drum noise without any kind of external comment driving that, so variety of as if I were writing a unit test. That ’ s more of what I would consider a white box test. I would consider what we & # x27; re doing with the GPIO stuff to be essentially black box testing. We & # x27; re just sending in electric signals, which is all that the buttons themselves do so, we & # x27; re fundamentally mimicking a functional interface to the device.

The solitary way we could make it more end-to-end is by building a robot that really taps the different buttons the way a human would. But what we & # x27; re execute with kind of have one layer beneath the physical button tap to sending electric signals, in my view, is precisely the same type of black box testing that Appium does with XCUI test your UIAutomator - where it & # x27; s not physically tapping the screen, but it is getting variety of one stratum below the glassful so to verbalize and synthesizing that tap case as if a user were actually tap it.

Q: What are the main welfare of using UIAutomator2 instead of Espresso?

A: The main benefit of UIAutomator2 is that you & # x27; re not limited to your own device that you feature a debug APK for. You can automate any application, you can automatize apps you don & # x27; t own, didn & # x27; t evolve, you can automatise various aspects of the device itself: button and other thing like that that just aren & # x27; t actually portion of Espresso, because Espresso ’ s designed for specific automation of a specific app.

I think the Appium team is investigating the power to combine both Espresso and UIAutomator2 into one session so that you can kind of hold the better of both worlds. So that when it comes to your covering, you hold this sort of gray box accession to it and all the welfare of Espresso, but you likewise then have the ability to tap around early applications or other constituent of the device. So, this isn & # x27; t available at the bit, but it & # x27; s something we & # x27; ve been exploring and appear like it might technically be possible. So that & # x27; s kind of an experimental form.

Q: Do you ask admin prerogative to work with Appium 2.0?

A: No. You having permissions for Appium won & # x27; t alteration. I mean some of the specific drivers have their own license poser. So for exemplar, like we talked about the Windows Driver demand admin permissions, but that & # x27; s not Appium itself and all the driver installation and management happens in your own user directory. So, unless you choose to put all of the drivers and plugins someplace that your user doesn & # x27; t have access to, Appium shouldn & # x27; t require exalted privileges to do all of its introductory operations.
If you ’ re interested in other webinars refer to Appium, don ’ t forget to check back here [] for more.

4 Parts

Connet Now