Gartner recently published a report that said: “application leaders should embrace AI-augmented development now, or risk falling further behind digital leaders.”* In today’s visual economy, customers are increasingly interacting with companies through a screen. For this reason, digital transformations are all about delivering quality at high velocity along with stability. To do this, leading firms of all sizes and verticals are embracing AI as a critical layer in their tech stack.

Why does AI matter to Digital Transformation?

Because it can help automate the error-prone and mundane tasks that often pull humans away from higher value tasks for an organization. The Gartner report states, “while early AI-augmented development addresses mundane, ‘plumbing’ tasks, this is exactly where application leaders can benefit from further automation and cost reduction.”*

However, we know that simply using AI for its own sake won’t get you very far. While these types of technological advancements can certainly help increase your productivity and increase the velocity of your software development pipeline, the areas where you can get the most proverbial “bang for your buck” is in processes that are either 1) entirely manual or 2) extremely frequent tasks (or sometimes both).

According to Gartner, “today’s statistical techniques are inadequate for optimizing testing, especially when changes to applications are frequent and where large software assets already exist that use a wide variety of microservices. Development and quality assurance (QA) in organizations cannot keep pace with the rate of innovation needed, due to: a heavy reliance on manual testing, skills gaps, insufficient resources, and an inability to scale technologies and processes. AI and ML are particularly suited to support the complex test automation required for back-end services within a mesh app and service architecture.* For more information from Gartner regarding microservices, visit 4 Steps to Design Microservices for Agile Architecture.**

__________________________________________________________

Gartner’s ‘Innovation Insight for AI-Augmented Development’ report is available to subscribers: (https://www.gartner.com/doc/3933974).

__________________________________________________________

Why is Digital Transformation difficult?

Consider the task of visually inspecting the user interface of an application or webpage. Oftentimes, this is still a job that is reserved for human eyes only. Someone — or rather a team of people — need to physically sit down and scan thousands of webpages across multiple browser types and devices, looking for inconsistencies and errors.

According to our 2019 State of Automated Visual Testing Report, today’s typical “Digitally Transformed” company now boasts 28 unique web and mobile applications, each with 98 pages or screens per app, viewable in five different screen sizes, and read in six different human languages. This amounts to around 90,000 screen variations accessible every day by customers. Here’s how that breaks down by industry:

90,000 screens. That’s a lot.

In fact, if you laid all those screens end to end, they’d extend over 17 miles (27 kilometers).

Imagine walking that distance, carefully checking a screen every step of the way. How long would it take you? Would you like to do that with every test run?

Probably not.

Because of this, we’ve found that a typical company incurs between $1.8M and $6.9M annually due to visual bugs that have escaped into production. Ouch!

What this data tells us is that it is not reasonable for humans to find the small inconsistencies in a webpage, especially ones that we are extremely familiar with. Just as you will “gloss over” a misspelling in a sentence when you know what it is supposed to say, it is very natural to “gloss over” a visual error when you know the color it’s supposed to be, or where the button is supposed to be positioned, or how the columns are supposed to align. But for your customers, who didn’t spend countless hours working on the website or application, they will most certainly notice the mistakes that you’ve missed.

In addition to the issue of familiarity, there is also the challenge of scalability. Reviewing 90,000 variations of how a screen looks is simply not sustainable in a time where the velocity of software release cycles is only getting higher.

So, realistically, what can be done?

Visual AI to the Rescue

We created Visual AI technology that emulates the human eye and brain with computer vision algorithms. These algorithms report only the visual differences that are perceptible to users. Also, they ignore insignificant rendering, size, and position differences that users won’t notice.

We’ve tuned these algorithms to instantly validate entire application pages, detect layout issues, and process the most complex and dynamic pages. And the best part? There’s no calibration, training, tweaking or thresholding required. Through years of engineering, we’ve gotten it to work with 99.9999% accuracy. That’s one false positive out of one million screens tested.

Using this Visual AI technology our AI-powered visual testing platform, Applitools Eyes, helps increase overall app UI test coverage by 60 percent and improves the overall visual quality of apps by a factor of three. With our Ultrafast Grid, you can gain the power our low-code, high availability, and easy-to-use visual testing platform to support your entire digital transform team: product owners, developers, test automation engineers, manual testers, DevOps, and marketing teams. Reach out or sign up for an Applitools demo today!

*Gartner, Innovation Insight for AI-Augmented Development; Analyst(s): Mark Driver, Van Baker, Thomas Murphy, Published: 31 May 2019

**Smarter with Gartner, 4 Steps to Design Microservices for Agile Architecture, 7 August 2018, https://www.gartner.com/smarterwithgartner/4-steps-to-design-microservices-for-agile-architecture/

The post Is AI Required for Successful Digital Transformation? appeared first on Automated Visual Testing | Applitools.

We are excited to share that Applitools has been recognized in the 2019 SD Times 100 Awards for ‘Best in Show’  in software development for the ‘Testing 2019’ category. This is the second year in a row that we have been recognized in the SD Times 100 for Testing.

The SD Times 100 has been honoring outstanding companies in software development and delivery for 16 years. The award recognizes companies that are the leaders, innovators, and influencers in the software development market and spans ten categories from DevOps, low code, big data, and more.

How are the SD Times 100 finalists selected?

The SD Times editorial team takes a careful review of each company within the ten categories to determine the strength of each offering, the product or services’ reputation, and the “buzz” around the company – are they prevalent and talked about in the market? We’re honored to be considered one of the companies shaping the software industry.

In fact, there’s been a lot of momentum building over the past year and we’ve made great efforts to both contribute to the software testing community and keep our AI powered visual testing and monitoring tool, Applitools Eyes, on the bleeding edge. Below are the latest advancements that kept Applitools in the running for the SD Times 100 this year:

• Ultrafast Grid: our Ultrafast Grid delivers the world’s fastest cross-device cross-browser rendering platform, by using lightweight container technology. How fast is it? We’ve seen people run 100 tests in just 20 seconds. Running more tests, in less time, lets you gain greater tests coverage and release higher quality apps.

• Applitools Root Cause Analysis (RCA): our RCA helps you pinpoint the cause of bugs in your frontend application code within minutes, eliminating hours from traditional bug diagnosis practices and letting you keep software projects and digital transformation initiatives on track.

• Selenium IDE: as you may know, Selenium IDE is a popular free open source record-and-playback testing tool. Applitools worked on the revamp of Selenium IDE and added an integration between Selenium IDE and Applitools Eyes. The integration, in the form of browser extensions for Chrome and Firefox, lets you visually test web applications using Visual AI across dozens of browsers and devices, in parallel, using our Ultrafast Grid.

• 2019 State of Automated Visual Testing Report: conducted as an independent survey of over 350 companies, the data outlines research findings for visual testing and quality and identifies key patterns that drive excellence in Application Visual Management. For instance, companies with significant Automated Visual Testing release 2.8x faster, and have a 3x improvement in quality, with fewer visual bugs escaping. If you need to persuade your management to invest in visual UI testing, check out this report.

• Test Automation University: in January 2019 we kicked off this free, community-driven educational training courses aimed at keeping software testing skills up to date and sharp. This initiative is led by Senior Developer Advocate and test automation legend, Angie Jones. There are now thousands of students enrolled, and 18 courses available. Each course can be taken on your own time with badges, certificates, and other perks for completing each course. We’ve been so humbled by the support of Test Automation University!

The most exciting part is there is so much more coming from us in the near future! Thanks again to SD Times for recognizing us in the 2019 SD Times 100 Awards.

If you’d like all of your apps and sites to be visually perfect, reach out or sign up for a free Applitools account.

The post Applitools, Visual AI Recognized in SD Times 100 for Second Year in A Row appeared first on Automated Visual Testing | Applitools.

We’re excited to share that Applitools has once again been named to the CB Insights 2019 AI 100!

This list represents the 100 most promising privately-held artificial intelligence (AI) companies in the world. These are companies using AI to solve big challenges, and we’re honored to be recognized alongside so many well-respected and innovative companies.

How did we make the list?

Through an evidence-based approach, the CB Insights research team selected the AI 100 from over 3,000 companies based on several factors: patent activity, investor quality, news sentiment analysis, their proprietary Mosaic scores, market potential, partnerships, competitive landscape, team strength, and tech novelty.

Want to give Applitools Eyes a try? Enjoy a free trial of our easy-to-use visual testing SaaS solution

Why Applitools?

Today, if your company has a digital presence, it has to be compelling. It has to be visually flawless. Any less, and you’ll lose the trust of your customers.

After all, you wouldn’t shop in a store with a broken sign. “If they can’t fix such an obvious problem, what else is wrong?” you’d think to yourself.

It’s the same with your digital presence. Visual glitches erode trust in your web or mobile app, which makes customers less likely to buy from you.

But it’s not easy to fix all visual bugs. Software development teams focus on constantly, rapidly delivering a drumbeat of new features. So, if you’re in QA, it’s hard to keep up and check every new feature. Especially given the wide range of phones and web browsers your customers might use.

Traditional functional testing tools aren’t well-suited for catching visual bugs — there are simply too many visual properties to check. So many QA teams revert back to manual testing, which is way too time-consuming to check everything in time.

So visual bugs escape into your release, are seen by your customers, and your business suffers. Like what happened to Amazon during its Prime Day sale last summer.

So, we here at Applitools want to help. We built a visual AI to help you automatically test and monitor your mobile and web apps. This way, you can be sure they appear correctly across all the devices, operating systems, browsers, and screen sizes your customers use.

We’ve been busy

Since receiving this honor last year, we’ve been busy building out our platform, making life easier for developers and QA teams. Back in April, we released the world’s first UI Version Control system that lets you view the history of an application UI over time, and see how it has changed, what has been changed, and by whom.

We also created an ultrafast visual testing grid that lets you test for visual bugs in dozens of combinations of browsers, screen sizes, and mobile device orientations — in parallel, in seconds.

And we released a new root cause analysis feature, letting you pinpoint the cause of bugs in application code within minutes, not hours.

Our goal with all of these releases? To eliminate hours from traditional bug diagnosis practices, and help you keep your software projects and digital transformation initiatives on schedule and looking great.

Helping QA professionals grow

However, it’s not just about new features. Applitools recently launched Test Automation University, to provide educational training courses to help improve test QA automation skill sets for all. Provided free of charge, these online courses help address the lack of accessibility to the training and educational resources needed to fill a growing skills gap in IT, and are vetted by some of the leading test automation experts in the world.

Make sure to stay tuned in the coming year for some more exciting announcements, updates to our solutions and the latest trends in test automation. And, thanks again to the CB Insights team for the honor of being added to the AI 100 list!

To read more about Applitools’ visual UI testing and Application Visual Management (AVM) solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo or sign up for a free Applitools account.

How are you looking to use AI to improve your product development and test automation? 

The post Applitools Named to CB Insights’ AI 100 List for the Second Year in a Row appeared first on Automated Visual Testing | Applitools.

Take a guess: how long have we been dealing with software bugs?

It’s not 30 years, around the time Windows was first released.

It’s not 48 years, the start of the Unix epoch.

It’s actually much longer. 71 years and 2 days, to be exact. Here’s why.

Back on September 9, 1947, Grace Hopper, a Harvard computer scientist, was running tests on a calculator and found calculation errors. She did some investigation and found a moth that had landed between two solenoid contacts, shorting out an electromechanical relay. Apparently, the bug had been attracted by the warmth of the machine.

We now commemorate this occasion every September 9, Tester’s Day.

As you can see in her logbook entry below, dated September 9, the actual offending moth was taped to the page. So not only is the first known example of a software bug, it’s probably the most tangible example of one as well.

71 years after Grace Hopper’s discovery, software continues to be infested with bugs of a more modern variety. Some of these have been pretty spectacular.

Like that time in the 80s when the entire world could have been destroyed due to a software bug.

Really.

The Bug to end all Bugs

Here’s what happened: a Soviet early warning system showed that five American nuclear missiles were flying to Russia.

You have to understand that this was during a particularly tense time during the Cold War, since the Soviets had shot down a Korean passenger jet three weeks earlier. And the United States and USSR both had over 50,000 nuclear weapons, each of which could destroy a city.

Thankfully, the Russian commander that saw this ignored the warnings, believing (correctly) that if the US were to attack the Soviet Union, it wouldn’t launch just five missiles. When the early warning system was later analyzed, it was later found to be riddled with bugs.

Thankfully, the bugs we’re seeing in 2018 are a bit less alarming.

But that said, they’re still pretty annoying in our day-to-day life, given how dependent we are these days on software. Let’s dive into some of them.

Trippy Text Layout

On the TripAdvisor mobile app, ratings are overlaid with the hotel name, making it so that, in some cases, you can’t read either. This doesn’t exactly encourage potential guests to make a booking on their app. And that’s a problem given how many travel booking apps there are out there.

Wanna Get A Way (to Book)

On the Southwest Airlines website, a visual bug prevented customers from clicking the Continue button and actually buying a ticket. The visual bug was that their Terms and Conditions text was overlaid on top of the Continue button. Southwest drives about $2.5M through their website every hour. So even if this bug was up for a short time, it would have cost them a lot.

The airline industry is very competitive. Not wanting to be left behind, United Airlines has done their part to cut off their revenue by hiding their purchase button behind text.

SerchDown

The ThredUp website prominently provides a convenient search field on its homepage. But it’s not so convenient to block access to buttons to view your shopping cart, or sign in to view your account.

No Order for You

On Amazon’s mobile app, there was a visual bug that prevented users from continuing the purchase process if they tried to switch their order quantity to something other than one. It’s like the software version of everyone’s favorite restaurant worker.

I’m Feeling Unlucky

For years, Google’s homepage has been minimalist in design so it loads quickly and they can help users find what they need and get on their way. However, this rendering of their website, using Chrome on macOS, seems to be taking minimalism a bit far.

Maybe privacy really is dead

Privacy permissions on social are a big deal. Some things you might okay with sharing publicly, and others you’ll want to share with just your network. With LinkedIn‘s overlapping privacy choices, whether a post is public or private can be a roll of the dice.

Repetitive Redundancy

Speaking of LinkedIn, they’re a bit repetitive here…

Repetitively Repetitive Redundancy

With another repetition-based visual bug, we’re treading into dead-horse-beating territory here, but Banana Republic really, really wants to let you know that all denim and pants are 40% off.

Alexa, are you done yet?

On the Amazon Alexa mobile app, if you rearrange the order of the podcasts in your flash briefing, the app will still appear as if a podcast is still “settling in” to its new location, and the app will appear to be hung.

Home Screen Blues

Apple’s iPhone home screen can sometimes improperly position the message that no older notifications exist.

Craigslist not looking so bad

There’s probably some really useful text in that leftmost column of the Facebook Marketplace. We’re just not sure what it is.

What language is that?

You never know what languages you’ll encounter on an airplane. This is why, on the Air Canada site, they explain their commitment to speaking to customers in their preferred official language, whether it be English, Chinese, or whatever that third choice is. (I’m surprised French isn’t listed.)

So why does software have visual bugs?

None of these examples are intended to throw developers under the bus. Writing code is hard.

Anticipating every possible scenario is near impossible. Your users continuously interact with all kinds of devices with a dizzying variety of operating system versions, browser versions, screen sizes, font sizes, and languages.

When you multiply all these together, the number of different combinations can easily be in the tens of thousands.

That’s a heck of a lot more than this pile of phones: 

So yeah, life’s not easy for developers.

At the same time, your web or mobile app is the now the front door of your business for an increasing number of users. And you have to ensure that storefront doesn’t have any visual glitches.

Unlike these guys: 

… Or these guys…

Conclusion

But back to the software world. There, visual perfection can mean the difference between one of your customers loving or hating your product. That why at Applitools, we want to help developers and testers come together to find one class of bugs — visual bugs — as quickly as possible through visual UI testing.

We might not save the world, but hopefully, we’ll save you a bit of time in getting a visually perfect app shipped into production.

To read more about Applitools’ visual UI testing and Application Visual Management (AVM) solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo or sign up for a free Applitools account.

What bugs have you seen in web or mobile apps? Tweet them out with hashtag #GUIGoneWrong. If we like your entry, we’ll ship you one of our “Visually Perfect” shirts.

The post What Types of Software UI Bugs Are We Seeing in 2019? Here Are 13 Examples appeared first on Automated Visual Testing | Applitools.

No frontend project can survive without an effective testing strategy. Why?

Because frontend projects can be as complex as backend projects — but users still expect a flawless experience. And if those users complain to your management… it’s just bad.

So, more and more frontend developers are realizing that they need to bake automated testing into their development process.

But questions remain:

• What testing should you do beyond unit testing?
• How can you find the time to both code and build/run/maintain automated tests?
• How do you maintain tests when requirements and features are constantly changing — and you’re pushing new code into production daily?
• How do you convince your boss that testing isn’t a waste of time?

We want to help you out of this.

Please join us at State of Frontend Testing, a free online event where frontend testing experts share how to quickly build high-quality web and mobile apps in 2019. We’ll cover the testing strategies, tools and frameworks you should be using in 2019.

Who’s presenting?

• Kent C. Dodds, JavaScript engineer at PayPal and creator of TestingJavaScript.com
• Gleb Bahmutov, JavaScript expert and software quality fanatic. VP of Engineering at Cypress.
• Shai Reznik, Founder of HiRez.io – Entertaining Angular + Testing Courses and TestAngular.com.
• James Evans, Software QA developer and Microsoft MVP.
•  Kevin Lamping, Front-end Engineer & Tester. Webdriver Fan.
• Rotem Mizrachi-Meidan, Mobile Infrastructure Engineer at Wix.
• Gil Tayar, Senior Architect at Applitools and creator of Applitools Ultrafast Grid
• Tracy Lee, co-founder, ThisDot Labs

Not a bad group, right?

State of Frontend Testing will stream live on Tuesday, December 18th at 10 am PST / 1 pm EST / 6 pm UK. This is a free, online event open to all developers.

Register here to see the event details and join the livestream.

We hope to see you on the 18th!

What will you do upgrade your frontend testing in 2019?

The post How to upgrade your Frontend Testing in 2019 appeared first on Automated Visual Testing | Applitools.

You know what’s crazy about software?

It’s the fact that, for many businesses, applications are a big revenue driver — maybe even the ONLY revenue driver. But we have no system of record to manage the development of our application user interfaces.

Let me explain.

Suppose your company’s revenue drops off. You learn that over the past quarter, revenue coming from mobile app has declined significantly.

You dig further. App downloads are unchanged. App performance is unchanged. App crash rates are unchanged and low.

In fact, the only change is in the UI. You’ve released several new versions over the past few months. So, some of these UI changes must be causing the revenue dropoff, you guess.

You decide to do some user research. Show them old and new versions of the UI and ask which they prefer.

But no one has a record of what the old UI looked like. Those designs are lost, washed away by the passing of time like a sand castle in surf.

It’s crazy that, in 2018, we have accounting systems to track our company finances, CRM to manage sales process — heck, we even have apps to manage our houseplants!

But there’s nothing to manage the application user interfaces that drive revenue for modern businesses.

Like I said: crazy.

So how do we fix this?

Introducing UI Version Control

We were amazed that, with so many businesses driving the bulk of their revenue through web and mobile apps, there wasn’t a way for product teams to track the visual evolution of their apps. So we built one.

We call this UI Version Control. It’s like a wayback machine for your apps.

UI Version Control lets you build software smarter by capturing the entire visual history of your apps, so you have a record of what’s been changed, by whom, and when — and what should be rolled back if the need arises.

Move Fast and Fix Things

Most important, UI Version Control directly links changes in the UI to underlying code changes in your GitHub code repository. This clarifies what code commits need to be undone in order to fix a user interface change that has hurt the user experience or revenue generation.

This helps your company on a number of levels.

They can release more frequently, secure in the knowledge that they know what code changes to make to roll back a feature that didn’t pan out.

They can begin to view application features as experiments — some of which will work, and some won’t — and iterate their way to an optimal UI.

They can de-risk the user-facing aspects of their Digital Transformation projects — many of which are at risk, due in part to lack of a system of record for digital transformation — because they have a way to back out of digital dead ends.

So how do you derisk Digital Transformation?

With a UI System of Record

Before UI Version Control, Applitools showed only baselines in the context of test results from the test results manager, and you weren’t able to view the history of a test baseline.

That’s all changed.

With UI Version Control, you can see the history of all your test baselines in each branch, compare them to prior versions of your baselines, and revert to an earlier version if necessary. You can do this by selecting ‘Save as latest’ from the baseline options menu. So, if you accidentally accepted a baseline that you shouldn’t have, you can undo your mistake.

UI Version Control works just like source code version control that you, or your developers, are already familiar with. Visual baseline branches can be merged in the same way that code changes are merged.

For each branch in your GitHub project repository, you can see the history of all your test baselines, compare them to prior baseline versions, and if necessary, revert to an earlier version. You can then reject and/or revert to any baseline modified by accident or by design.

Here’s a demonstration from our CTO, Adam Carmi, of UI Version Control:

Conclusion

Applitools UI Version Control is now immediately available to all Applitools customers. So, while we might not be able to prevent you from building bad UIs, at least we’ll help you undo them faster.

To read more about Applitools’ visual UI testing and Application Visual Management (AVM) solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo or sign up for a free Applitools account.

What recent UI changes to your app are you worried about? 

The post How to improve your user interfaces with UI Version Control appeared first on Automated Visual Testing | Applitools.

Why is Jira so hard to use for bug tracking? This seems to be a continual refrain heard on the web: “Jira isn’t suited for Agile development”. “Jira is complex and bloated”. “People cram too much information into Jira”. Another common complaint is that Jira tickets are simply unmanageable.

Organizing JIRA tickets pic.twitter.com/2YeDNc7tcf

— Mike Herchel (@mikeherchel) October 2, 2017

But, love it or hate it, Atlassian Jira is very popular for bug tracking and can be found within many software development organizations worldwide. If your workplace is one of the many that uses Jira, you might want to consider using Applitools Eyes to make your visual user interface (UI) testing easier.

First, some background: Applitools Eyes lets you automate visual UI testing of your web and mobile application front end. Using Applitools Eyes ensures that your application’s UI is displayed consistently and accurately across any device, browser, or viewport. Atlassian Jira manages your development workflow, task tracking, issue management, and reporting.

Integrating Applitools Eyes and Jira will save you time, especially if your visual tests detect many defects. Manually logging visual defects may take a lot of time: grab a screenshot, draw a circle around the defect, write some text explaining what the problem is, create a Jira ticket, attach a screenshot, then have a follow-up call with a developer because they didn’t understand your write-up. This may easily add three to five minutes just to report and explain one software bug.

Three to five minutes per bug? What a time sink…

There’s a better way: integrate Applitools Eyes with Jira. Doing this lets you directly report issues to your engineering team, and track those issues to resolution. Highlight a region, write a quick comment, tag your teammate responsible for investigating, and you’re done. A bug report with screenshots with highlights of all visual differences, along with your comments, filed in Jira and your teammate is notified. Total time: about thirty seconds to file a bug.

With the manual tasks of reporting and tracking out of the way, testing teams can focus on increasing test coverage (and leaving the office at a reasonable time). This post explains how to quickly report issues and defects captured by Applitools Eyes to a Jira project.

Configuring Applitools

First, open the Applitools Eyes Admin panel and locate your team. Find the Jira section on the page and click the checkbox to enable the integration. In the text box, type the URL of your Jira server. Next, specify the Project ID (PID) and the ID of the relevant issue type for the target project. If your project uses additional Jira fields, type the field name into the text box and press the Add button. In the drop-down menu, select a field type. Alternatively, you can type the name of a custom field into the text box. After you provide all the relevant configuration information, save it.

Applitools Eyes Jira Integration in Action

Now that you have configured the Applitools Eyes Jira integration, we will show you how to use it. In this example, we will simulate a defect in an existing web application (Gmail), and then use the integration to create a new Jira issue. The test inspects Gmail’s More button and detects a typo. When a test detects an issue, click the Create New Jira Issue button. This opens a new browser tab that displays the Jira Create Issue form. In the form, each field you specified during the configuration process contains the relevant Applitools Eyes test information. You can edit the information in the form and populate any empty fields. When you are ready to create the issue, click the Create button.

After you save the detected defect, Jira creates an issue that includes the name of the test, the batch in which it was running, the step description, the time when Applitools Eyes encountered the issue, the execution environment in which it was running, and any custom properties you defined for the test. The issue includes a link that lets you view all the defects in the Applitools Test Manager. This allows you to examine the recorded visual validation in context and compare captured screenshots with the test’s baseline images.

You can add existing visual regression test results that were not linked to a Jira project using the Link to Jira issue dialog box. The dialog box lets you enter an issues Applitools ID and add it to Jira. After you add an issue from Applitools to Jira, click the View in Jira button from an issue region or the Collaboration View to view the defect in Jira. You can also use the dialog box to link to a different Jira issue, or you can just delete the link.

Find visual UI bugs before your customers do

In this post, we explained how our Applitools Eyes and Jira integration can boost your team’s productivity. Integrating Jira with Applitools will help you streamline communication with your engineering team, which will allow for more efficient management and tracking of issues. As a result, your software development team will ship better quality software in less time.

But productivity is only part of the picture. It’s absolutely critical that you don’t let visual user interface bugs escape into production. When this happens, your customers will lose trust in your software and brand.

Even worse, you can have a visual bug that blocks customers from buying, such as this glitch on the Southwest Airline’s website. See how the text is overlapping the Continue button? Because of this, the Continue button doesn’t work, and customers can’t book a flight.

From a business perspective, this bug is disastrous since it is blocking revenue generation and is actively driving customers to competitors. It’s these kinds of revenue-killing production bugs that software QA and development teams need to be able to report and act on quickly, and 

So, once you’ve integrated Applitools and Jira, what will you do with all the time you’ve saved?

If you are a Jira user and want to read more about Applitools’ visual UI testing and Application Visual Management (AVM) solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post How to Make Jira Easier to Use with Integrated Visual UI Bug Tracking appeared first on Automated Visual Testing | Applitools.

Until the late 1960s, no one thought computers needed a user interface (UI), and the UIs that did exist were expensive and primitive. At the time, these UIs were being used by the military for air defense systems, were built as academic research projects, or were used as props in science fiction movies.

Then, UI pioneers such as Doug Engelbart and Alan Kaye, and Ted Nelson had the crazy idea that people should be able to interact with computers and do useful work. By the late 1970s, the first UIs began to emerge at Stanford University and Xerox PARC, and they were then quickly copied by Apple and Microsoft. Today, UIs are everywhere: watches, refrigerators, cars, phones, and—of course—computers. In addition, software platform vendors have created tools that give anybody who wants to create a UI the ability to do so. Many of these tools, especially those used for web development, are simple to use and—even better—free!

But no matter how much easier or how much cheaper it becomes to build a UI, building a good UI will always be hard. In today’s world, any developer who creates customer-facing applications has to know more than how to write code; they need to understand design principles and have some artistic talent, too. With so many devices and UIs vying for our attention, and with the relentless progress of Moore’s Law continually forcing down the price of electronic hardware, the look and feel of software is becoming an increasingly important part of users’ purchasing decisions.

In short, your UI is the face of your application. Therefore, your application’s visual UI will determine whether a potential customer uses your product or service, or permanently deletes your application. Ensuring that your application looks and functions as expected requires intensive and expensive automated and manual testing. In this post, we explore a revolutionary solution from Applitools that gives you what no other automated testing solution can.

The Problem 

Most developers make tremendous efforts to ensure their applications work. Many of them invest time in running and debugging their source code and trying to build something that not only works, but also solves real problems. However, no matter how hard they try, developers are often working in isolation, and they can’t anticipate all the ways their software will be used by their potential customers. For their part, users don’t care how hard a developer worked. All they want is something that looks good and works as advertised. For a user, the way software looks matters—and if it doesn’t look right, it’s broken.

If all an application developer had to do was make things that looked decent, most of them would probably be able to develop the necessary skills and deliver great products to their users. Unfortunately, there is another unforgiving factor in this equation: time. Time is one thing that developers do not have. With today’s rapid development cycles and large number of browsers, operating systems, devices, form factors, and screen resolutions, it is more difficult than ever to test whether your application is working exactly how it should be in each area.

Until recently, the only way to comprehensively test an application was to put it in the hands of testers. These testers would run scripted or ad-hoc scenarios to manually test applications in real-life conditions. The advantage of using manual testers is they can perform tasks that computers and automated test scripts can’t. For all its benefits, manual application testing has a number of drawbacks. It is an expensive and time-consuming process. And because of its boring and repetitive nature, manual testers may begin to miss or underplay visual issues.

The Solution

Applitools has developed a revolutionary solution for this problem. Applitools Eyes uses advanced cognitive vision technology, which makes it completely different from any other existing testing tool. Applitools Eyes detects any differences between two screen displays and can replace hundreds of lines of testing code with one smart visual scan.

Applitools eyes is the first automated software testing tool that tests your application like a manual tester does—except that it works much more quickly and accurately. Applitools Eyes can test web applications on multiple browsers, including Chrome, Safari, Internet Explorer, etc., and it can test in as many screen resolutions as you want. It can also test a mobile application on an iPhone, iPad, or iPad mini in both portrait and landscape orientations.

Getting Started 

Getting started with Applitools Eyes is quick and easy. All you need to do is add calls to the Applitools Eyes cloud service from your existing automated tests. Alternatively, you can choose to send screen captures of your application directly to Applitools Eyes, in which case you will receive the added benefit of visual UI validation immediately.

Applitools Eyes does more than just run visual UI testing—it is also a complete Application Visual Management (AVM) solution that manages and analyzes your test results. So, Applitools lets you manage the enormous number of baseline images generated by your visual UI tests, it records and aggregates the results of visual tests, and it shows you which tests were passed and which were failed. It also allows you to analyze test data and generate meaningful reports and analysis. Additionally, Applitools ensures your test baseline remains relevant and is not polluted by inaccurate data. Applitools Eyes provides unique tools to manage your testing baseline, and it removes misleading information being propagated in such a way that it leads to information overload or hides potentially damaging issues.

In addition to all the great and unique features Applitools Eyes offers, it also works well with many existing test automation and management systems. Applitools Eyes works with many existing test automation frameworks, including Selenium, Appium, WebdriverIO, Microfocus (formerly HP) Unified Functional Testing (formerly QuickTest Professional), and 40 others.

Join the Visual UI Testing Revolution

In a relatively short time, computers have developed from massive industrial machines that did relatively simple tasks to what Steve Jobs referred to as “bicycles for the mind”. They have gone from communicating via punch cards and printers to using a range of visual and audio interfaces. In general, computer technology has changed rapidly, but one thing has remained constant: building an attractive UI for your apps is still hard, and if you get it wrong, you risk losing potential and existing customers.

To build great UIs, you need to invest in coding and testing. You need to create tests that behave like real people and that perceive the visual aspects of your software like real people. This is where Applitools can help you. Applitools Eyes is a smart, innovative testing solution. Using Applitools will give you the benefits of manual testing, but will also provide you with the added benefits that come with using advanced automated cognitive vision technology. With the help of this product, your software will be tested quickly, efficiently, and accurately.

To learn more about Applitools’ visual UI testing and AVM solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post Applitools Eyes: Introduction to Automated Visual UI Testing appeared first on Automated Visual Testing | Applitools.

All organizations that build software realize that testing is an integral part of the software development process. Like many important tasks and processes, it is not fun. When we are assigned testing tasks, we regard them as an unwanted burden. 

What many of us fail to recognize is that testing is more than just checking our source code runs. Testing is really about collecting data that helps our organization plan, organize, and track decisions. Testing data is a strategic asset that will impact a company’s future growth and financial well-being. Nothing hurts a software company more than releasing buggy and unreliable products that no wants to buy. In the short term, no one will buy your wares, and in the longer term, your reputation may never recover.

There are two things you need to do to get the most out of your testing. First, you need to use a testing system that saves you time and effort, tests the things that matter to real users, and puts the fun back into testing. You can do this with visual user interface (UI) testing. Visual UI testing lets you create tests that detect the visual problems that matter most to real users. Second, you need a system that records all test data and makes it available to the relevant people when they need it. For this, you need an Application Visual Management (AVM) system. An AVM system collects, manages, and analyzes all the data you collect from your visual tests and makes it available to anybody who needs it. The goods news is that you can achieve both of these goals with Applitools Eyes.

Applitools Eyes is a unique test management solution that manages the visual testing process. In this post, we will give you a quick tour of the Applitools Eyes Test Manager. Then, we will show you how to use the Test Manager to display test results, edit tests, and update baseline images.

Applitools Eyes Test Manager: Quick Tour

The Test Manager is divided into two main regions: the sidebar and the center panel. 

Sidebar

The Sidebar is located on the left side of the Test Manager. It displays all recorded test runs, with the newest runs listed at the top. Each run includes a batch of tests. By default, each test run is displayed as an individual batch. However, you can use the Eyes SDK to group multiple tests together into a single test run.

Center Panel

The Center Panel shows you the details of the currently selected batch. It provides a number of different views for displaying and managing your test results. Note that in all views, you can use the filter to find steps, tests, and batches of interest.

Test Details View

This view lets you inspect and sort tests by operating system, browser, viewport size, and start time. You can group tests together and create your own hierarchies using the available properties. Clicking on a test will reveal thumbnails of the screenshots that have been sent for validation.

Batch Steps View

This view shows validated screenshots in a single group and ignores the test run/batch from which they originated. In addition, this view can create a single representative screenshot that groups a number of steps with the same and/or similar differences.

Batch Summary View

This view lets managers and team members to assess the status of the batch quickly. It also allows you to visualize key metrics, such as the pass/fail ratios per test, and the test status distribution grouped by browser, operating system, and viewport size.

Managing Test Runs

When you run a test for the first time, the Test Manager marks it with a green label. The label indicates that this is a new test run, that the test was passed, and that its screenshots were used to create a baseline. The plus sign in the upper left corner of the thumbnail indicates that this is a new step that did not previously exist in the baseline. The thumbs up symbol indicates that Applitools has accepted the screenshot and included it as a baseline image. In addition, any test or screenshot that matches the baseline will be marked as passed, and its steps will appear with a green stripe and an equals sign.

A test with differences is marked as unresolved, which indicates that this test contains steps with differences that have not yet been reviewed and resolved. Steps with differences are marked with a not equal sign and the differences are highlighted in pink. Clicking the Radar button highlights the differences. These differences are resolved by accepting or rejecting them. You accept differences that represent valid changes to the application under test, and you reject differences that represent defects, issues, or test failures. You accept step differences by clicking the Accept button and reject them by clicking the Reject button. By default, if you reject any differences, the entire test is failed. Conversely, if you accept all differences, each step will be passed, as will the entire test. You can override the default test result by clicking the test label and choosing another status.

Viewing and Updating Baselines

When you want to review a test run, click on the appropriate thumbnail image. The image will be displayed in the Test Editor. The Test Editor provides additional baseline editing tools. For each test, a timeline is displayed at the bottom of the screen. This shows the individual test steps and indicates the result of each checkpoint. Using the toolbar’s Match Level menu, you can change the level of matching (Exact, Strict, Content, or Layout) between the current image and the baseline image.

The Test Editor allows you to switch between different views. In the side-by-side view, it displays the baseline image and the current image. In full-page view, you can toggle between the baseline and current image. In both views, you can highlight differences between the current image and the baseline image by clicking the Radar button. For each image, you can zoom in on differences by clicking the Next or Previous buttons. The Test Editor allows you to accept or reject differences within the current step. You can also accept or reject the differences between all steps that have the same difference.

You can indicate whether a difference caused by a dynamic area of your application should be ignored or not by placing an ignore region on top of it. The Auto Adjust Regions feature lets you propagate the ignore region to steps containing the same dynamic area. Any future images captured by Applitools Eyes that include the ignore region will be marked as passed. However, these changes will not be applied to future test runs once the changes have been saved to the baseline, and existing test results will remain unchanged. Steps and tests that contain changes that have not yet been saved to the baseline will have an asterisk next to their name. To save or change the baseline, click the Save button. As expected, the next time you run your test, it will be marked as passed because its screenshots will match the updated baseline.

Effective Testing and Test Management

In this post, we showed how the Applitools Eyes Test Manager can help you manage your visual test runs. Not only does it provide a comprehensive and easy UI, but it also offers many unique and powerful tools that allow you to view individual tests and test runs. Using the Test Manager, you can update your visual testing baselines and propagate those changes across all your tests.

Furthermore, the Test Manager lets you work however you want to. If you want to review each individual test and baseline change, you are able to do so. But you can also take advantage of powerful features that review changes automatically. After you make changes, Applitools Eyes handles the process of updating the relevant images in the test baseline. This is one of the many advanced Application Visual Management (AVM) tools Applitools Eyes provides that can help you manage and update your baselines, handle tedious and repetitive tasks, and allow you to focus on more productive, higher value tasks. Visual testing is one of the most effective testing methods, and the new Applitools Eyes Test manager will help you unleash its full potential. 

To learn more about Applitools’ visual UI testing and AVM solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post Getting Started with Applitools Eyes Test Manager appeared first on Automated Visual Testing | Applitools.

Many people think of GitHub as a niche website that hosts open-source projects. In June 2018, that niche website with a mere 28 million users got more media attention than Apple’s Worldwide Developer Conference (WWDC). Somehow, a site that provides free services was so valuable that Microsoft acquired them for $7.5 billion US dollars.

Since its launch in 2007, GitHub has grown far beyond its roots as a web-based service that provides a hosted version of the Git-distributed version control system. The site hosts open-source projects and also offers paid plans for developers and companies. With the adoption of agile development and DevOps practices, it has become an essential part of the continuous integration/delivery/deployment pipeline for many companies. Not only do these companies host their source code in private GitHub repositories, but they also integrate their repositories with their continuous integration (CI) systems.

An important part of any CI system is the ability to run automated tests on any code committed to a source control repository. The automated tests help prevent new code from breaking the software built by the CI system. Now, with the release of the Applitools Eyes GitHub integration, you can include automated tests that perform visual UI testing as part of your build process. Visual UI testing lets you create tests that accurately simulate real users interacting with your software. The integration also takes care of uploading test results to Applitools’ advanced Automated Visual Management (AVM) system for analysis.

This post explains how you can use the Applitools Eyes GitHub integration to perform visual validations for pull requests. Integrating Applitools Eyes with GitHub prevents visual defects from merging into your production software. For each pull request, it merges the baseline screenshots of the branch along with your source code, and runs automated visual validation tests.

Applitools Eyes GitHub Integration

Applitools Eyes ensures your application looks and functions exactly as expected across all browsers, operating systems, devices, and screen resolutions. In addition to handling application testing, the Applitools Eyes GitHub integration lets you use Applitools Eyes as an integral part of your build automation process.

The Applitools Eyes GitHub integration automatically configures the baselines used for obtaining and saving test baselines. It displays the status of your tests directly in the pull request page, right next to the merge status. The integration lets you view the history of an application’s user interface (UI) and see how it has changed, what has been changed, and by whom. This will show you how your product’s UI has evolved over the product’s lifetime. The feature allows you to merge visual testing baseline branches in the same way you merge changes to your test and source code. For each branch in your GitHub project repository, you can see the history of all your test baselines, compare them to prior baseline versions, and if necessary, revert to an earlier version. This feature lets you reject and/or revert to any baseline you modified by accident or by design.

Visually Validating a Pull Request

In order to illustrate how to use the Applitools Eyes GitHub integration, we created a complete demo that includes all the relevant source code files and project-related assets. The demo is called merge-demo, and we made it available as a GitHub repository. The demo runs visual validation against the Applitools Hello World test page. The test navigates to the Hello World page, visually validates it, clicks the Click Me button, and visually validates the page. In this demo, the Hello World test code has been modified to test the page in two different viewport sizes.

Configuring the Integration

Before you can run the demo, you need to install and configure the Applitools Integration application. In the merge-demo repo, open the Settings > Integration & Services page. The page indicates that the Applitools Integration application has been installed. The page also indicates that the Travis CI service has been configured to build and run tests.

Creating the Pull Request

To create the pull request on your PC, open a terminal window and clone the merge-demo locally. Create a new branch, called mybranch, and modify the tests. Commit the changes and push them back to the remote branch. Now, create a pull request to merge the changes with the master branch.

Building the Request

After receiving the Pull Request, Travis CI initiates a build for the pushed pull request. For the sake of simplicity, we recommend you disable the Builds for the Pushed Branches option; otherwise, Travis CI will build two individual branches.

When the build is complete, open the Pull Request page. The Test Applitools status indicates the status of all visual tests that ran as part of the build. We can see the two tests detected differences. If you click the details link, it will take you to the corresponding page in the Applitools Test Manager. The batch contains two tests with different viewport sizes. The test name includes the branch name, the name of the pull request, the source branch, the commit message, and the SHA. Using the page, you can accept the changes made to the first test and reject the changes made to the second test.

Managing and Merging Baselines

Reopen the Pull Request page and you will see the Status Description now indicates that one of the visual tests has been failed. If you accept the changes in the second test, you can see the status changes to green to indicate that all of the visual tests were passed. By looking in the Test Details, you can see the tests were configured to run in the source branch. After reviewing the test results, you save them to the baselines of the source branch. The updated baselines will not affect any tests running in other branches.

After updating your baselines, you can check that other team members did not make conflicting changes to the baseline. You can do this by checking the SCM status of the Applitools request, which is currently pending. Next, open the Pull Request page. This page displays the details of all the changes in the baselines, compares them, and allows you to edit the source baseline by porting ignore regions and locations from the target baseline, or by adding new ones. The page shows that the Applitools SCM status changed to green and no baseline conflicts were found. This means the two changes in the source branch are ready to be merged with the target branch. As soon as your source code is fully merged, Applitools will automatically merge the changed baseline in the source branch with the baseline of the target branch.

Visual UI Version Control

In a very short time, GitHub has grown from an obscure developer-centric website into an essential tool for a wide range of enterprises. It serves the needs of freelance contractors, large corporations, and governments. GitHub may have started as a cloud-based version control system, but today, it provides additional services such as project management, online documentation, web hosting, and defect tracking. For many companies, GitHub has replaced their on-premises source control management systems, and it functions as an essential piece of their CD/CI tooling.

In this post, we looked at how to use GitHub as part of your DevOps stack. We explained how the Applitools Eyes GitHub integration automatically configures the baselines used for obtaining and saving test baselines, how to create pull requests, and how you can add visual test validation to your CI pipeline.

This solution gives you powerful tools that ensure each time a pull request triggers a build and merges your target and source branches, it also gives you control and insight into the process. The integration also simplifies the process of reviewing and managing visual test baselines. More importantly, it is a form of UI version control that shows how your application’s UI has changed and evolved over time. These Applitools Eyes GitHub integration benefits will ensure the quality of your products and will benefit your end users and customers.

To read more about Applitools’ visual UI testing and Application Visual Management (AVM) solutions, check out the resources section on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post How to Test Your GitHub Pull Requests so You Don’t Break Your UI appeared first on Automated Visual Testing | Applitools.

Whether you’re a test automation engineer or a manual tester, it’s crucial to track what your test environment is. This enables your developers to easily replicate bugs found and avoids the frustration of not being able to reproduce those problems.

It’s also important to track your web or mobile app user interface history using a UI version control system. This helps your developers, product managers, and designers understand what’s been tried, what’s worked, and what hasn’t worked so that the entire team can iterate the UI rapidly, in an Agile fashion, to a product that works well for customers.

As part of our continued rollout of Application Visual Management (AVM), in Applitools Eyes version 10.4, we’ve made it easier to manage your visual UI test environment setup, as well as your web application and mobile app user interface history. Let’s dive into these new features:

1. Visual Test Environments view
2. Visual Test History view
3. GitHub Enterprise integration
4. Batch & Branch management
5. Table Configuration manager
6. API Update

Visual Test Environments View

When you run cross-device and cross-browser visual UI tests, you need to indicate the details of the different baseline that you want to run against. One way of doing this is to provide the name of the baseline test execution environment. To recap, an Applitools test environment denotes a particular combination of operating system, browser, and viewport size.

Previously, getting the name of the baseline environment wasn’t as easy as we wanted it to be. So in Applitools Eyes 10.4, we’ve made it a lot more straightforward, with a new page, Environment, which lets you:

• View all the test execution environments for your team
• Add one or more names to any environment
• Delete test environments that are no longer relevant to you

You can also group environments by operating system, browser, viewport, or environment name, which makes it easier to manage environments. For example, if you no longer support Windows 7, this makes it easier to hide all test environments related to Windows 7 so that they don’t clutter up your workflow.

Visual Test History View

The new Visual Test History view lets you drill into the timestamp and status of any application test run across all the browsers, viewports, OSs, and branches that comprise your team’s test environment configuration. It’s like a Wayback Machine for your visual UI tests, but with the added help of a whole bunch of meta-data about what changed, who changed, when they changed it, etc.

On this view, the test status is also shown, with the option to drill into the test results page to view a test’s batch group and evaluate the visual differences between your baseline and a particular test run.

You can also sort, filter, or group your visual tests by various parameters, and delete any previous tests where necessary. This is especially helpful once you have months or even years of test runs. You can filter by a wide range of test run attributes, including:

• Assigned To
• Branch
• Browser
• Issues & Remarks
• Operating System
• Regions
• Saved status
• Started status
• Step status
• Test status

For instance, you can see all visual test runs occurring on Android 5.1 or Android 6.0 that have failed or have unresolved differences. With this granular level of filtering, you can zero in on exactly the test runs you’re looking for.

The Visual Test History view can be navigated from the Apps & Test or the Test Results pages when looking at a specific test result. See below on how to find this command.

GitHub Enterprise Support

In Applitools Eyes version 10.2, we released support for GitHub — the public cloud service. In 10.4, we’re adding support for GitHub Enterprise, the on-premise software. This offers all the same capabilities, including:

• Integration of Applitools visual tests with GitHub pull & push request workflow
• Applitools baseline branching mapped to GitHub codebase branching
• Compare baseline Applitools visual test results across branches as part of the GitHub merge process

With this integration, you specify your GitHub Enterprise server, as well as which repositories you’d like to connect with for the purposes of visual testing.

Branch Management

With Applitools Eyes 10.4, whenever you have a list of branches, you have a new way to delete or rename a branch.

First, let’s talk about deleting branches. To be clear, deleting a branch merely hides it from the list of branches. Deleting a branch is helpful if you’re dealing with the development of a feature and don’t need that branch anymore. This prevents your list of branches from getting longer and longer.

Now let’s cover branch renaming. Suppose you have a branch called “Dev” which is later named “MyCompany/Dev” in GitHub. So instead of creating a new branch, or copying everything from the Dev branch to the MyCompany/Dev branch that GitHub is using, you can just rename your branch. Much simpler.

Batch Management

Two small but important features we added are the ability to rename batch runs, and the ability to delete batch runs. Granted, it’s not going to solve world hunger or anything, but hopefully, this makes it a bit easier to manage your visual testing.

Table Configuration Manager

Applitools captures a lot of visual UI testing information. But what is useful to one test automation engineer isn’t as useful to other. For this reason, Applitools Eyes now lets you customize many of the table views in the product. You can hide and show columns, resize them, and reorder them. Plenty of other products have this capability — the macOS Finder and Windows File Explorer come to mind — and now it’s in Applitools as well.

API Update

We’ve enhanced our APIs for better integration with third parties, including Testim.io and Micro Focus StormRunner Functional.

Specifically, we’ve now added a merge key. This key is useful if people are integrating their merging control systems with our merging capabilities. You can provide them with the merge key instead of the update key, and they can use it to only perform merges through the API. What we’re doing is applying the principle of least privilege to our API.

You can see the merge key in the Applitools Admin Panel. The merge key is created for all new accounts, even for free accounts that don’t have a view key or update key.

Next steps

We’ll be releasing comprehensive documentation on these new features soon; however, to learn more about our UI baseline features in general, visit our documentation pages.

To learn more about Applitools’ visual UI testing and application visual management (AVM) solutions, check out the tutorials on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post How to Track Your Visual UI Test Environment and History appeared first on Automated Visual Testing | Applitools.

We just released version 10.3 of Applitools Eyes on our Application Visual Management (AVM) platform and would like to tell you about three great new capabilities we added:

1. UI Version Control
2. New View: Apps & Tests
3. New View: List View of Test Baselines

1. User Interface Version Control

UI Version Control lets you view the history of an application UI over time, and see how it has changed, what has been changed, and by whom.

Up until now, Applitools has only shown baselines in the context of test results from the test results manager, and you’ve never been able to view the history of a test baseline.

Now in Applitools 10.3, you can see the history of all your test baselines in each branch, compare them to prior versions of your baselines, and revert to an earlier version if necessary. You can do this by selecting ‘Save as latest’ from the baseline options menu. So, if you accidentally accepted a baseline that you shouldn’t have, you can undo your mistake.

You can also merge baselines branches just like you merge your code changes. This gives you a lot of flexibility around baseline management.

This capability is essentially version management applied to the concept of the visual aspects of your application’s entire user interface. We call this User Interface Version Control, or UIVC. And we are the first company to build this.

Another benefit of Applitools’ UIVC is that it gives you a system-of-record to understand how your product’s UI has evolved. We found it amazing that, in 2018, with so many businesses driving the bulk of their revenue through their app or website, there wasn’t a place to go to see the visual evolution of your product. So, we went out and built one!

Here’s a demonstration from our CTO, Adam Carmi, of our new UI Version Control:

2. New View: Apps & Tests

The second new feature in Applitools 10.3 is Apps & Tests View. In Applitools, visual tests have always been associated with their respective baselines and been part of an application group. However, there hasn’t been an easy way to visualize this taxonomy of apps, tests, and baselines from the test results manager.

In 10.3, a new user interface screen labeled Apps & Tests now lets you:

• View a list of all applications and their corresponding tests with the ability to filter, rename, or delete in the application list or the test list.
  • Note: any time you rename an application or test, you should also update your test script so that Applitools doesn’t create a new test during subsequent runs.
• View details on each test such as the last test execution date and baseline update by user.
• View all baselines for a test by selecting Show Baselines from the options panel for a test.
• View last executed or saved result for a test in the Test Results Manager from the options panel.

3. New View: List View of Test Baselines

The third new update in 10.3 is a list of all baselines for a given test. You can get to this screen from the Apps & Tests screen by clicking on a test, as well as by clicking the options icon for a given test.

The screen lets you:

• Group baselines by various parameters
• Filter baselines by branches, name, and status parameters
• View related details such as properties, last saved date and total tests run
• Drill into the history of any baseline from the options panel

To learn more about Applitools’ visual UI testing and application visual management (AVM) solutions, check out the tutorials on the Applitools website. To get started with Applitools, request a demo, or sign up for a free Applitools account.

The post Applitools Introduces UI Version Control appeared first on Automated Visual Testing | Applitools.