Find more bugs faster with less test automation code
Brittle, flaky functional test code is a problem
If you’re in functional test automation, you or your team probably write a lot of test scripts. And that
takes a lot of time. You have to figure out locators and labels, and ensure everything is just right.
For example, suppose you had to test this simple login page:
In addition, when you create an account, we process your information as described in our
Request a Demo
Get a one-on-one demo with an expert.
Your message has been sent
Here’s the test script you’d need to write in Java to run in Selenium:
Phew! That’s a lot of code for just a simple page. Even if you’re experienced, it’d probably take you
an hour to write.
But what happens when your app updates, and looks like this -- broken logo image, overlapping text,
new field prompts, and new text for your terms and conditions?
You or your team needs to review all that assertion code to ensure it’s still valid. Every object locator.
Every label. And write more brittle assertions to catch the bugs you missed.
Realistically, that could take you an hour or more -- for just one screen. For all the screens in your app,
those hours will add up to days or weeks. And if your app updates daily or weekly, you might not be able to keep up.
All this test maintenance leaves you less time to write new tests. Less test coverage. And more late-stage
bugs that can lead to schedule slips.
Modern apps have complex bugs
Responsive web pages, native mobile apps, and progressive web apps can have all kinds of bugs that can’t be caught
with legacy assertion code. These can include overlapping UI elements, elements suddenly appearing or disappearing,
improper sizing, and more. Here’s an actual example from Instagram:
With all the jumbled text, a user can’t even click on this ad. This blocks ad revenue generation -- not something
senior management wants to see.
But how would your legacy testing tool even begin to detect these kinds of issues? All it can do is check text
values and maybe a few other attributes. So bugs escape, undetected. And you get blamed.
There’s a better way.
Functional testing for modern apps through Visual AI
Applitools provides a fresh approach to functional testing by building Visual AI:
Replicates the human eye and brain through computer vision algorithms, to see
your app as your customer does.
Spots meaningful differences between versions of your app’s user interface.
Ignores minor differences that your users don’t notice.
Detects unexpected app changes that your traditional testing tools miss.
Works out of the box, having been trained on billions of images over 6 years.
Simpler test scripts
With the Visual AI in Applitools Eyes, you no longer write assertions focused on just one object.
Instead, one call to our SDK -- eyes.checkWindow() -- captures your entire web page or mobile app
screen, then sends it to our visual AI for analysis.
No more writing line after line of assertion code. Your test scripts become much simpler -- and
much easier to maintain.
And you can detect all bugs, even complex layout issues like our Instagram example.
Back to our login page example above. Here’s the script to test that page using Visual AI:
Visual AI makes our script a LOT simpler than before. No locators or labels to maintain -- yet we find ALL the bugs on our page.
Visual AI takes a different approach to app changes -- whether good (new features) or bad (bugs).
Instead of forcing you to maintain your test scripts by fine-tuning assertions and constantly adding new ones, Applitools
Eyes groups all similar changes that it finds across multiple
screens of your app.
You then specify whether each change is expected or an unexpected bug, with one button click. Here’s an example:
This is a lot quicker than reading through assertion code to update locators and labels. What previously took you
an hour for one page now takes seconds for multiple pages. That’s a lot of time saved!
You and your team will shave days from your test maintenance efforts. You can use that time to increase test coverage.
Shorten your test schedules. Or get home on time.
Ultrafast cross-browser testing
For web apps, our SDK can send your page’s DOM snapshot to our Ultrafast Grid,
where it can be rendered on up to hundreds of web browsers in parallel, in seconds. Each browser can contain different
combinations of browser type -- Chrome, Firefox, Edge, or IE -- viewport size, and user agent string
(to simulate mobile devices).
This lets you get thorough test coverage of responsive UIs, so you can rest assured that you’ve found all bugs on all
browsers and viewport sizes.
For web app bugs, our Root Cause Analysis displays the DOM and CSS
differences that underpin visual differences. This slashes debugging time from hours to mere minutes. Here’s an
example of it in action:
Integrates with your entire test stack
We don’t believe in rip-and-replace. That’s why we have over
50 SDKs, for all popular test automation frameworks -- and some you’ve probably
never heard of.
If you’re already using JUnit, TestNG, or some other assertion library in your test scripts, you can keep using it and
incorporate our SDK so you can ensure that it catches all bugs. Then when you’re ready, remove the other assertion
libraries so that you have simpler, easier-to-maintain test scripts.
Applitools integrates with all popular DevOps tools and
CI systems. So it fits right into your CI/CD process.
Focus only on what matters
Unlike simplistic pixel-comparison tools, Visual AI doesn’t highlight false positives -- fake bugs -- that waste
your time. And frustrate your developers.
Here’s an example of pixel comparison differences:
Since the horizontal bar changed thickness, everything below it is highlighted as a change. Not very useful right
Now here are differences according to Visual AI:
Only the horizontal line and button are highlighted. Exactly what a human user would notice, and no more. This saves time
for you and your team, so you can focus on expanding coverage and accelerating test schedules.