This post is the third in a 3-part series on visual testing with Appium. Visual testing is an important family of testing and can get visual fixation as well as functional bugs. The inspiration for this serial comes from a I make for. Check it out! (And don & # x27; t forget to say the and parts in this series first).

In Part 1 of this serial, we put together our own homebrew visual testing solution. In Part 2, we discussed 4 limitations of that unproblematic result, and exhibit ways to ameliorate some of those difficulty by conduct advantage of the Applitools optic testing SDK. We did not, however solveallof the problems. There are a couple issues (which we listed out earlier) still remaining that we demand to address:

• Applitoolsdoestake attention of some gravel ever-changing chip of the device screen. By default, for example, we will not run into any topic with the device time changing. But what about content inside our app that changes from test to test?
• The eq of & quot; full-page screenshots & quot; -- so far, we haven & # x27; t seen how to take screenshots and make comparisons usingallof the point in a list view.

Enabling full-page optical comparison

Let & # x27; s take # 4 foremost, since it & # x27; s comparatively easygoing to address within the context of the Eyes SDK. It & # x27; s actually simply an SDK flag; to have Applitools automatically scroll any scrollable views and sew together content to form one long screenshot, call the setForceFullPageScreenshot command with the value true:

eyes.setForceFullPageScreenshot (true);

The reason this functionality is not enabled by default is that there is a sure measure of overhead involved in detecting scrollable prospect and then in really scrolling them, so it should be turn on only when you know the comparing will be worth the spare time. Of line, you can besides turn it on and off throughout the line of a trial.

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

Let & # x27; s take a aspect at this functionality in activeness. The two edition of my examination app that we & # x27; ve been using in example so far both check a habitation screen with a bit of constituent on it. What happens if I run a visual test comparing the home blind of V2 of the app with the baseline give from V1 of the app? The codification I & # x27; m running looks something like this:

@ Test world void testHomeScreen () {eyes.open (driver, `` TheApp '', `` appium pro home screen scroll test ''); // wait for an element that 's on the domicile blind waitForElement (wait, LOGIN_SCREEN); // now we know the home screen is loaded, so do a visual check eyes.checkWindow (CHECK_HOME); eyes.close ();}

This is about as simple a trial as we can imagine; it simply waits for an element to appear on the habitation screen, and performs a visual check. When I run this test on Applitools, I get a ocular differences warning. This is to be expected, because I feature add some items to the home screen in V2 of the app. But have a expression at the Applitools page where I go to have a expression at the conflict:

Notice that the screenshots are of real different acme. This is because, with V2 of the app, we scrolled the home view to make certain to get all the different elements. Thus here we get a genuinely good view of everything that alter. Without full-screen curlicue, we might observe a alteration, but not the extent of it. And if we had a V3 of the app which added even more items, we wouldn & # x27; t notice any departure at all without scrolling.

Ignoring insignificant visual differences

The final trouble we require to solve in order to have ourselves a nice and rich visual testing pipeline is the trouble of false positives. How can we create sure our visual testing logic isn & # x27; t tripped up by ocular differences that don & # x27; t actually signify anything?

For example, in our test app there is a little & quot; echo screen & quot; that takes some user input and then displays it back on the screen. We could compose a little functional-plus-visual test of this functionality with some code like that below:

@ Test public emptiness testEchoScreen () {String msg = `` hello ''; eyes.open (driver, `` TheApp '', `` appium pro echo screen test ''); wait.until (ExpectedConditions.presenceOfElementLocated (ECHO_SCREEN)) .click (); wait.until (ExpectedConditions.presenceOfElementLocated (MSG_BOX)) .sendKeys (msg); driver.findElement (SAVE_BTN) .click (); WebElement savedMsg = wait.until (ExpectedConditions.presenceOfElementLocated (MobileBy.AccessibilityId (msg))); Assert.assertEquals (msg, savedMsg.getText ()); eyes.checkWindow (CHECK_ECHO); eyes.close ();}

This code is nada new; it just finds and interact with elements in very standard ways. The first time we run this test, there are no ocular erroneousness. In fact, we could run it again and again, and there would be no problem. But what if, to satisfy some external requirement, we needed to modify the msg variable to check a different twine, like & quot; cosmos & quot; rather of & quot; hello & quot;? The succeeding time we run the exam, we & # x27; ll be recognise with optic conflict that trigger a admonition:

‍

‍

This is reasonable, but windy. We didn & # x27; t actually change anything about the optical design of the app, and this is not a bug. So why waste our time looking at false positives like these? We can actually direct Applitools toignoreregion of the blind that change frequently or merely with content that is unimportant to visual examination. To do that, we simply choose the & quot; ignore area & quot; puppet and draw boxes around the area we don & # x27; t wish about tracking:

‍

Once we relieve these regions and the baseline, we can update our code again (maybe create the msg variable contain the string & quot; Appium & quot;), and rebroadcast the test. This clip, we don & # x27; t get any notification of ocular difference, and if we log into the Applitools app, we can see that the check was marked automatically as & quot; passed & quot;, even though we can see quite clearly that the strings disagree between the two runs:

‍

This is exactly what we require! Now we & # x27; ve uncouple the schoolbook used in the functional aspect of the test from the optic checks. If you want to see the code for both of the above sections in the context of a runnable project, you canensure it out on GitHub.

Optic testing conclusion

In this 3-part series, we & # x27; ve find how to use Appium & # x27; s built-in image processing technology (powered by OpenCV) to build out some introductory visual testing capableness. We & # x27; ve also looked at the chief problems that are crucial to solve in order to have a functional, maintainable, and robust visual testing model. Thankfully, projects like exist which provide some of these solutions in an off-the-shelf fashion through the use of language-specific SDKs. Of trend, you could also go the route of finding solution to the basic framework & # x27; s limitations on your own or through a combination of other puppet. Either way, I hope this series has encouraged you to get started with adding at least a few visual tests to your build, if you don & # x27; t have any yet! And if you want a more in-depth edition of these brief tutorials, don & # x27; t forget to ascertain out on Test Automation University.

4 Parts

Connet Now