What's New at Applitools

In this release, we introduced a new AI-based comparison feature to handle dynamic text. We added a new method for defining regions based on web elements to help you with test accuracy and maintenance. We also made it easier to gain insights into your test results with new dashboards on the Insights page.

Handle tests when the text is constantly changing

The new Dynamic match level identifies text patterns such as a date, number, or more and only identifies a difference if the text pattern is broken. You can use default text patterns or create custom ones with Regex, and apply these settings at the application, test, step, or region level. Learn more

New dynamic regions that correspond with your web elements

You can now define regions based on web elements, this means that Eyes can identify the region even if the size or position has changed. This method can be used in addition to manually drawing coordinates on the screen. Learn more

New insights dashboards

We have introduced new dashboards that provide insights into automated testing coverage, display the time saved by resolving steps with automated maintenance and show detected issues over time. Learn more

And there’s more…

• Source code management (SCM) integrations: Merge and commit information will now be included on the baseline history page.
• SCM integrations: Improvements have been made to the setup process, minimizing the need to manually configure environment variables when integrating SCM with Eyes.
• Tests requiring attention: Performance improvement and fixes.

Chrome upgraded to version 128

Preflight Updates

• Custom HTTP Request Headers: Users can now add global and test specific custom headers for their tests.
• Test Suite Scheduling: Users can now set up Suites for scheduled executions.

We’re excited to announce a major upgrade to the Applitools Intelligent Testing Platform: Autonomous 2.0! Packed with powerful new features and enhancements, Autonomous 2.0 enables any team member – regardless of coding skills – to create, execute, and analyze automated tests. This release introduces an innovative AI-assisted interactive test authoring experience, enabling users to create complex tests quickly and efficiently. It also includes a range of new significant features designed to further expand Autonomous coverage into functional testing, and significantly accelerate test maintenance and results analysis.

Learn more

Interactive live browser and test recorder

• Users can write tests in plain English and instantly view results while adding steps
• Expedite the test writing process by clicking on the browser—each action is automatically translated into a test step

API testing

• HTTPS requests can now be made directly from within a test
• JavaScript execution is now supported, enabling users to run JavaScript through user action steps

Non-visual assertions

• Supported assertion types include: text and string assertions, numeric value assertions and element count
• Users can view assertion outcomes with passed/failed status

Dynamic regions based on web elements

• Users can now define regions based on web elements
• Users can add padding and leverage auto-maintenance capabilities to apply these regions to other test steps

Auto-correction language model (LLM-based)

• Each new step that required a fix will be reviewed by the auto-correction model
• The step will be corrected with the necessary fixes

Enhanced results review experience

• Enriched the presentation of plan and test results to provide a better review experience
• Includes a summary of results for each plan and test, highlighting any issues found

TestGenAI records user actions in the browser and automatically generates Cypress test scripts accordingly, featuring advanced capabilities like self-healing and automatic data generation. An innovative solution enabling technical and non-technical team members to expand test coverage quickly and effectively while significantly reducing maintenance effort and ensuring high-quality code.

Product highlights:

• Time Savings: Recording user actions quickly to generate tests while eliminating the need to write code manually for each step.
• Robust and Stable Tests: The tool automates mundane tasks like filling in forms and provides amenities that improve the overall quality of the generated test code, making tests more robust and easier to maintain over time. It also includes an advanced self-healing functionality to ensure stable tests and a minimal maintenance effort.
• Modern Test Coverage: Quickly create modern test coverage in code using Cypress, which includes industry best practices, and allows easy migration from existing test implementations, such as Selenium to Cypress.
• Allow Non-Developers to Author Tests: Distribute the test creation workload and empower non-technical team members to contribute to test automation.

Github Integration

Teams can now connect multiple GitHub organizations simultaneously when using the Applitools Github Integration with a local Github Instance (via the proxy service).

Execution Cloud

• Review videos of tests that ran on the Applitools Execution Cloud directly within the Eyes UI.
• An enhanced tunnel solution for testing lower environments, with a better TLS connection, improved identification, and reduced IP addresses for whitelisting.

SCM Integrations

• Enhanced the merge branch workflow by improving the criteria that defines a conflict.
• Improved the workflow when merging changes from the master branch to feature branches (reverse merge).
• Added new REST APIs for improved integration with SCM tools by updating the test result status earlier in the pipeline.

Eyes UX Improvements

• Automatically abort idle test runs after a period of inactivity.
• Usability updates to the “Tests Requiring Attention” screen, including advanced filters and a share option.

Preflight Execution Cloud Integration

An integration between Preflight and the Execution Cloud is a significant step towards tighter coupling between Preflight and Applitools to enrich our service offerings for our customers. This integration promises exceptional performance and guarantees scalability in cross-browser testing, thanks to the robust framework of the Applitools Execution Cloud and Ultrafast Grid.

Secure Tunnels

Users can now add a secured modern TLS connection based tunnel to test against internal environments and websites that cannot be accessed externally.

Improved native mobile iOS solution with Native Mobile Library

A modern framework that overcomes the limitations of common native mobile automation frameworks (appium, XCUI, WDIO) and perform fullpage screenshot of the native mobile applications.

Applitools Autonomous

We are thrilled to announce the launch of Applitools Autonomous, a groundbreaking solution designed to transform the QA process and ensure that businesses can deliver flawless digital experiences faster and more efficiently than ever before. As we step into a new era of quality assurance, Applitools is leading the charge with innovative solutions designed to revolutionize how businesses approach testing across applications and documents.

Learn more

Applitools Intelligent Testing Platform

With three powerful solutions—Autonomous, Eyes, and Preflight—the Applitools Intelligent Testing Platform redefines industry standards for flexibility, coverage, and ease of use. Ready to try it? Contact your account manager to start a free trial.

Automatically generate tests for an entire web application / website

Applitools Autonomous Testing scans entire websites and multi-page web applications to generate tests for all pages, while Visual AI validates the entire UI for any functional or visual regressions (Full website test).

Guide the AI in plain English to verify custom user flows by leveraging our advanced NLP engine

With natural language test building and contextual UI testing, teams can author tests with Generative AI capabilities and leverage Visual AI to improve coverage and test reliability.

Easily generate Visual AI based tests for selected pages

Allows testing a list of URLs that can be specified via the UI or imported from a file. Enables an easy verification of all the selected URLs across different environments both visual and functional aspects are covered.

Easy scheduling of test runs on various devices, browsers and viewport sizes

With autonomous plans, users can run one or more test together using the same environments and schedule (daily, weekly, monthly etc.).

Automatic functional and visual analysis of the results to alert on changes and potential issues

Autonomous detects visual disparities and unexpected alterations on any of the website / web app pages. There is an auto-detection of technical issues for any of the website / web app pages, including HTTP errors, page timeouts, etc. Additionally there is an auto-detection of pages that were added / removed from the website / web app on each run.

Automated test maintenance

Autonomous provides you with a powerful set of features that significantly reduces your test maintenance overhead when you have many tests, and tests that run across multiple operating systems, browser types, device types, and screen sizes. The Automated test maintenance features work by identifying and grouping steps that have similar visual differences that require verification, as well as replicating the maintenance actions that users perform.

Support getting Eyes test results before finishing the test suite

Added support for Eyes.getResults() method that allows users to get the test results before the end of the test suite.

Test Requiring Attention Dashboard

We added a new view that enables our customers to efficiently review and maintain tests that require their attention. Customers can access this view through a new entry in the navigation menu, called “Tests requiring attention”. In this view, we have included some insightful statistics that highlight the top test scenarios that require review – making it easier to prioritize the work.

No-Code Test Authoring using Applitools Preflight

This release includes full support for authoring tests using the Applitools Preflight no-code solution. This solution enables our users to inject Visual AI into their testing process, regardless of their team’s skill set.

Root Cause Analysis Improvements

Eyes is able to now better handle encoded DOMs and give meaningful answers about what HTML or CSS changed.

Eyes UX improvements

We added additional UX enhancements to the “Save” procedure, making it more intuitive for all users.

Preflight Eyes Visual AI Integration

Users can now benefit from Visual AI-based validations without writing a single line of code, using Preflight for their test authoring. The results of the Visual AI-based checkpoints will appear in Eyes, and the information about the status of each validation will be reflected in the Preflight dashboard. This rich integration also includes support for our Ultrafast Grid for effective fast cross-environment testing.

Added support for reloading the page after resizing the viewport with layoutBreakpoints and UFG

Websites with a different logic per different viewport, can use the reload option when using layoutbreakpoints and the Ultrafast Grid.

Preflight Standalone Release

Release of Applitools Preflight, the no-code test platform that enables anyone to create, execute, and maintain powerful end-to-end tests.

Added support for Playwright C# SDK – May 2023

Announced a new Playwright C# SDK that allows customers to run Eyes tests with that automation framework.

Integrate with Applitools Self-healing Execution Cloud – May 2023

Added support for running Selenium and WDIO tests on Applitools Self-healing Execution Cloud platform, using the Applitools Selenium and WDIO SDKs.

Self-Healing Execution Cloud

Applitools now enables teams to run existing Selenium and WebDriver.io tests on our cloud-based execution platform at scale.

Learn more about Applitools Execution Cloud

Visual Source Control Management for Azure DevOps

Eyes Visual Source Control Management, can now be used as a source control with all our VSCM features.

Learn more

Enhanced Server REST API

We have extended the “list batch results” API to include additional data on test steps, including information about issues & remarks, and accessibility status information.

Learn more

Eyes Accessibility & UX Improvements

Better support for a11y standards including vast improvement of our tactile experience using keyboard shortcuts.

Save maintenance time and effort with Eyes & Self-Healing Execution Cloud

Applitools has introduced the Self-Healing Execution Cloud which is tightly integrated with Applitools Eyes. The Self-Healing Execution Cloud allows to quickly, easily, and accurately run any Selenium and WDIO tests at scale, and benefit from our innovative self-healing mechanism. The self-healing functionality prevents functional and visual tests from failing, even if there are changes in the application, by automatically identifying and fixing broken element locators.

Shorten the debug period of failed tests

Applitools Execution Cloud helps to find the root cause of a failed test by providing a video record of the session and all the webdriver commands were during the test

Secure Tunnel

Test lower environments with Applitools Execution Cloud and a secure tunnel.

Non-Eyes Tests

Applitools Execution Cloud allows you to run both Eyes and Non-Eyes tests on the platform, using the self-healing mechanism for your entire test suite.

Run tests on the Execution Cloud using Australian region

Applitools Execution Cloud allows you to run your tests on Australian dedicated region

Handle retries of flaky tests to avoid false negatives in the results – April 2023

Applitools SDK removes automatically duplicate tests to handle auto retries of flaky tests.

Full support of Storybook 7. Added support for configuration per story and improved performance.

Following a few requests from different customers & prospects, we’re happy to let you know that a new Playwright Java SDK is now available. This SDK is the second Playwright SDK that we offer, as Playwright JS support is already available since 2020. Read more here.

Improved Result Tracking

Each checkpoint approval or rejection is now stamped with the user’s info for better tracking and auditing.

Enriched Email Notifications

Email notifications just got a whole lot more informative. Emails now include test name, test environment, test step notifications, and more.

Share Visual Locators

Easily share and copy visual locators from different applications and environments.

Store Baseline Images Locally

Users can now download baseline images to their local machine for auditing and other purposes.

SCM Integration Improvements

SCM status updates have been improved so that it takes additional baseline events into account. In addition, we have added the ability to see the GitHub status on empty tests as well.

Enriching our Source Control Management integrations

• GitHub integration enhancement: Eyes now supports integrating multiple GitHub organizations with each Applitools team in your account.
• Monorepo support: To better support cases in which multiple organization projects are stored in a single repository, the team name has become an integral part of the PR status so that one can divide tests by Applitools teams.

Enhanced support for Coded Regions with Dynamic Content

When using coded regions based on an element identifier, Eyes can now adjust the region automatically and make sure it covers the most up-to-date element dimensions. This ignores irrelevant diffs and saves more of your time!

New server REST APIs

New APIs have been added to easily allow updates to batch properties and validate API keys. This helps when integrating Applitools with additional automation tools.

Eyes Accessibility Improvements

Multiple UI updates and improvements have been added to improve the accessibility of our product to all users.

Support for Cypress 10

Play Functions Support

Mobile Notification Panel

Assign A Test

The ‘Assign test’ functionality has been extended and improved to allow users to follow up on their assigned tests not only for sessions. Users can now filter by assignee and efficiently manage their tests.

Auto-Reject

The “Reject” functionality has been updated so that now, when users reject a specific checkpoint image, Eyes will automatically mark this checkpoint image as rejected on the next test runs as well. This will reduce the amount of time needed for reviewing the test results.

Export Batch Results API

You can now export full Batch Results via our API, making it easy to teams to pull down large sets of test results from the Applitools Test Cloud to use in their own internal systems and workflows.

New Filter

One of our most requested features, you can now filter test results and batches by who ran the test. A new “Run by” filter makes it easy to deep dive into a particular team members tests quickly.

• Firefox updated to version 95

Selenium 4 Support

Support for Selenium 4 for Java, Python, C#, Ruby

Storybook

Support Checking Story Variation via query params inside Storybook

Shadow Dom Support

Support targeting an element inside Shadow DOM for Selenium Ruby, Selenium Python, and Selenium C#

Full Page Screenshot

Support for taking a full-page screenshot on devices for Appium Python, Appium Ruby, Appium C#

• Microsoft Edge upgraded to 96

• Chrome upgraded to 96

• Safari iOS upgraded to 15
• Safari desktop upgraded to 15

• Firefox updated to version 94

• Edge upgraded to version 95

New integration with Microsoft Teams

In addition to sharing test results on both Slack and via email, the new Applitools Eyes-Microsoft Teams integration provides you with the option to receive and view your test results via your Microsoft Teams chat.

Enhanced baseline creation for new browsers and OS versions

Eyes identifies the most relevant baseline to reuse whenever you test on a new browser/OS version. It also allows you to easily filter and group baselines according to the browser or OS version you would like to explore. This capability is enabled by default for new accounts, for existing users please contact support to turn on this new & important capability for your accounts.

Receive more focused test results notifications via Slack integration

Slack notifications can now be sent according to selected batch properties.

Ensure perfect UI with each commit with GitHub integration

Update the test status on all commits.

Enhanced Rally integration

In addition to opening issues from within the Eyes dashboard, now automatically trigger an update in Rally when closing issues in Eyes.

Benefit from UX improvements for marking multiple regions

Keep the draw mode active when adding multiple regions of the same type.

• Chrome upgraded to version 95

• Firefox updated to version 93

• Edge updated to version 94

• Chrome updated to version 94

• Firefox updated to version 92
• Edge updated to version 93

• Chrome updated to version 93

Python Robot Framework

Initial Release

• Firefox updated to version 91

• Chrome updated to version 92
• Edge updated to version 92

• Firefox updated to version 90

Eyes dashboard accessibility improvements:

As part of our effort to make our product accessible to all users, UI updates were added according to WCAG 2.0 WCAG 2.1 accessibility global standards and guidelines.

Eyes new onboarding:

A step-by-step guide for new users in new teams.

Ensuring perfect UI with all commits:

The Bitbucket integration now updates the test status on all commits.

SAML

Improved the provisioning process with the SAML integration for dedicated cloud and on prem systems: The integration now supports defining the permissions level for users.

• Upgraded Chrome to 91
• Upgraded Chromium Edge to 91

Typescript Support

Typescript Definitions now available

• Updated GitHub integration via GitHub App.
• New Eyes proxy service for improved connectivity of on-prem GitHub & BitBucket servers.
• New Broadcom Rally integration for faster and more detailed bug reporting.
• Improved auto-maintenance capabilities for A/B testing variations.
• Ability to define custom properties at the batch level, set values per batch, then manage & filter via Eyes UI.
• Eyes dashboard now supports Safari.
• Eyes dashboard accessibility improvements.

• Upgraded Chromium Edge to 90

• Upgraded Chrome to 90
• Upgraded Firefox to 88

• Upgraded Chromium Edge to 89

• Upgraded Chrome to 89

• Upgraded Firefox to 86

• Upgraded Firefox to 85

• Upgraded Chromium Edge to 88

• Upgraded Chrome to 88

• Upgraded Firefox to 84

• Added support for Safari on MacOS 11

• Upgraded Chromium Edge to 87

• Upgraded Chrome to 87
• Upgraded Firefox to 83

Puppeteer

Initial Release

Nightwatch

Initial Release

• Upgraded Firefox to 82

• Upgraded Chromium Edge to 86

• Upgraded Chrome to 86
• Safari on iOS 14 support added for simulation of various Apple devices

• Upgraded Firefox to 81

• Upgraded Chromium Edge to 85

• Upgraded Chrome to 85
• Upgraded Firefox to 80

• Java 3 & Java 4 SDKs consolidated into Java 3
• Full page mobile native capabilities
• Up-to-date Classic (Selenium) capabilities
• Ultrafast Grid capabilities

• Upgraded Firefox to 79

• Upgraded Chromium Edge to 84

• New In-product learning center provides quick access to contextual help, technical support, documentation, and more.
• Smart Assist powered by Visual AI provides contextual tips with recommended maintenance.
• GitLab source control integration added.
• The batch filtering functionality has been enriched.
• The tables’ usability has been enhanced, making them easier to use when reviewing large amounts of data.
• The disabled regions indication and behavior has been improved.  
• New “undo” functionality was added for test steps.

• Upgraded Chrome to 84

• Safari on iOS support added for simulation of various Apple devices

• Upgraded Firefox to 78

• Upgraded Firefox to 77

• Upgraded Chrome to 83
• Upgraded Chromium Edge to 83

• Upgraded Firefox to 76

• Added support for Chromium Edge

• Upgraded Chrome to 81
• Upgraded Firefox to 75

• Upgraded Firefox to 74

• Performance increases for large sets of data, such as a batch or applications that contains thousands of tests, or a very long list of branch baselines.
• New filter to quickly show all tests that ‘require attention’.
• Updated UI for filters with improved visibility of applied filters.
• Updated UI for grouping (now located next to filters in the toolbox panel).
• New workflow for joining teams complete with admin approval and instant notifications.
• Pagination for lists of batches, branches, and tested applications.
• JS SDKs have changed the way that branching works to align with Git. These changes ensure your tests in the feature branch don’t break even when the master branch is constantly updated.
• Admin’s can now add users to a team or teams during the user creation workflow.

• Updated underlying dependencies to support 10.9 fallback mode

• Upgraded Firefox to 73

• Upgraded Chrome to 80

• Selenium Ruby SDKs now have grid support
• Selenium Python SDKs now have grid support

• Added support for Safari 13
• Added support for Safari 12
• Added support for Safari 11

• Fixed UX bug with the tooltip when downloading the visual grid config
• Added Safari as a browser option when running on the visual grid Trello 179
• Updated the UI to refer to the visual grid as the “Ultrafast Grid” Trello 179
• Updated underlying Applitools SDKs to latest Trello 144
• Updated underlying and transitive dependencies to resolve security vulnerabilities

• Upgraded Firefox to 72

• Changed the user agent formatting sent to Eyes

• Upgraded Chrome to 79

• Added support for check commands in nested tests
• Added C# code export support
• Added Ruby code export support
• Added accessibilty support to code export
• Fixed bug in the runner when setting the accessibility level

• Upgraded Chrome to 78
• Upgraded Firefox to 70

• Your add-on Applitools for Selenium IDE has been updated on addons.mozilla.org (AMO). Version 1.8.1 is now available for download in our gallery at https://addons.mozilla.org/addon/applitools-for-selenium-ide/.

• A/B Testing – manage multiple baseline variations per each tested page. Learn more here.
• Visual element locators – reliable object identification using our Appium Java SDK (more to come)! Draw and define named visual elements to locate their coordinates and interact with them. Learn more here.
• Slack and E-mail Integration – receive easy-to-read notifications when the execution of a test batch is completed. Learn more here.
• Partial save of baseline – save the changes applied to tests even if the issues on that baseline have not been resolved.

• Your add-on Applitools for Selenium IDE has been updated on addons.mozilla.org (AMO). Version 1.8.0 is now available for download in our gallery at https://addons.mozilla.org/addon/applitools-for-selenium-ide/.

• Upgraded Firefox to 69.0.1, including an OS upgrade to the latest version of Ubuntu (18).

• Your add-on Applitools for Selenium IDE has been updated on addons.mozilla.org (AMO). Version 1.7.8 is now available for download in our gallery at https://addons.mozilla.org/addon/applitools-for-selenium-ide/.

• Upgraded Chrome to 77

• Upgraded Chrome to 76
• Upgraded Firefox to 69

• Updated ultrafast-grid-client and related dependencies

• Added new devices to Ultrafast Grid device selection

• Updated ultrafast-grid-client SDK & React version

• Updated underlying dependencies

• Updated ultrafast-grid-client SDK version
• Updated transitive dependencies to resolve audit warnings

• Upgraded Firefox to 68

• Initial release.

• Moved IE & Edge as selectable browsers for the Ultrafast Grid out from behind the experimental feature toggle
• Fixed Python’s code export for check element commands when they use a CSS selector
• Updated the underlying SDK for local image processing

• Added a new command – eyes set pre render hook1
• Updated the underlying SDK for the Ultrafast Grid

• Added JavaScript code export support

• Added Python code export support

• Insights, which offers a dashboard with analytics and statistics for tests and batches. More here.
• Hide Displacement Diffs, to hide differences that arise from content whose position on the page has changed. More here.
• Bitbucket integration, to keep Eyes and Bitbucket branches in sync. More here.
• New SDK API BatchInfo.setSequenceName, for Java, C#, and JavaScript Selenium 4.

• Upgraded Chrome to 74
• Upgraded Firefox to 67

• Underlying SDK upgrade
• Added support for enablePatterns and useDom, through an expermiental feature toggle in the UI
• Fixed a bug in result parsing when dealing with an incomplete results object

• Eyes WebdriverIO Service integration is now available at https://www.npmjs.com/package/@applitools/eyes-webdriverio4-service

• Underlying SDK upgrade which removes the need to use eval for domCapture and domSnapshot

• Fix for fetching external assets with the correct referrer
• Underlying SDK upgrades which fix mysterious mysteries

• Applitools for Selenium IDE Version 1.1.0 is now available for download in the Mozilla Add-ons Gallery at https://addons.mozilla.org/addon/applitools-for-selenium-ide/

• Java API compatibility.

• Java API compatibility.
• Ultrafast Grid support for the Selenium SDK.

• This is a release version that includes the Ultrafast Grid. It also includes a bug fix for making the VG default to full page.
  Also updated to match the base code for this version:
  • Eyes.Appium 3.9

• • Eyes.Images 2.4
  • Eyes.Windows 2.5
  • Eyes.CodedUI 2.4
  • Eyes.LeanFT 2.6

• Render now times out only when the Ultrafast Grid will send a timeout result, or if no response is available at all.
• Improved Ultrafast Grid’s logs.

• Fixed viewport sizes override bug in Ultrafast Grid.
• Added missing fields in BaselineEnv class.
• Fixed a field’s casing in TestResults class.
• Fixed a bug in DOM capture script for Ultrafast Grid causing wrong renders due to missing elements.
• Fixed a bug in DOM capture for Root Cause Analysis causing a crash in certain cases.

• Correctly handling mobile web applications when AppiumDriver is passed.
• Fix: “getIsOpen” method caused a crash when usign the Ultrafast Grid.
• Fix: Proxy configuration previously ignored.

• Includes fixes for Root Cause Analysis when using the Ultrafast Grid, as well as correct “close” behavior (throw by default).

• @applitools/eyes-selenium@4.16.0 includes fix for additional compatibility with the Java (updated “close” behavior and runner.getAllTestResults).

Added missing script-hooks for Ultrafast Grid.

• Added alias command line args for SB static dir (-s)

• Added Section support (SB v5 supports defining sections for UI components – like directories).

• wct-eyes@1.2.1 Dependencies fix for @applitoos/eyes-common.

• Fix for getting input elements’ value property

• Added missing legacy APIs (e.g., getDevicePixelRatio, getScaleProvider).
• Updated DOM capture script, including fixes for input element value grabbing.
• Added preliminary AgentSetup data to Ultrafast Grid.
• Added DeviceInfo field. Device name would appear correctly now for device emulation.
• Updated BrowserType enum – IE_10 and IE_11 (instead of IE10/11) to match all other SDKs.

• Fixed support for IE_10 in addition to 11, additional compatibility with the Java version.

• Fixed check_region for Ultrafast Grid.

• Fix for getting input elements’ value property

• Fixed support for IE_10 in addition to 11, additional compatibility with the Java version

• Added support for WebdriverIO v5 with Ultrafast Grid

• Visually validate on multiple browsers and viewports with our Ultrafast Grid

• Updated to match new SDK Core

• Updated to match new SDK Core

• Updated to match new SDK Core

• Updated to match new SDK Core

• Updated to match new SDK Core

• Fixed viewport resize issue for multiple open-close on the same Eyes instance.

• Updated to match new SDK Core

• Includes a bugfix for updating global configuration after a test had started.

• Includes a bugfix for check_region_by_element when not using EyesWebDriver.

• Includes full compatibility with the Java API. Specifically, VG use is by providing a VisualGridRunner to the Eyes constructor, and providing configuration via “setConfiguration” (can be set both as a new configuration object) and as a plain JS object. It also includes support for IE/Edge.

• Includes full compatibility with the Java API. Specifically, VG use is by providing a VisualGridRunner to the Eyes constructor, and providing configuration via “setConfiguration” (can be set both as a new configuration object) and as a plain JS object. It also includes support for IE/Edge.

• Eyes.Selenium Ultrafast Grid Beta version was updated to version 2.21.7-beta
• Bugfix: Full page screenshot issue
• Bugfix: incorrect “close” behavior
• Bugfix: target element support for Ultrafast Grid
• Added special regions support for Ultrafast Grid
• Added support for IE and Edge in the Ultrafast Grid

• Root Cause Analysis bugfixes for frames infinite loop and JSON escaping
• Appium bugfix
• JRE 9/10 compatibility

• Includes a fix for ignore/floating regions when using the Ultrafast Grid.

• Includes complete DOM layout matching support and an update to setting the configuration object.

• Allows setting use_dom/enable_patterns globally.

• Includes a bug fix for handling storynames with dashes and spaces.

• Bugfix related to mobile emulation.

• Adds Ultrafast Grid support and DOM layout matching support (API is fully compatible with the standard eyes.webdriverio SDK).

• Bugfix: RCA used incorrect endpoint
• Ultrafast Grid bugfixes: use cached resources on multiple steps, API compatibility with Selenium.

• Bugfix: handling Appium property of battery info, DOM capture related fixes
• Internal refactoring for better frame handling.

This version re-instates the unified API of Selenium and the Ultrafast Grid Beta, and includes fixes for the issues found in version 3.145.1 (missing API methods, and invalid configuration order).

• First version of EyesEarlGrey SDK (EyesEarlGrey version 1.0.0) was published to Cocoapods. It is still considered beta.

• Now available as part of the @applitools/eyes-selenium package, version 4.7.0. The Ultrafast Grid beta also has an identical API to the Selenium SDK, for making the switch as easy as possible between Selenium and the Ultrafast Grid.

• Ultrafast Grid beta – unified API: Based on the feedback we got from our initial Ultrafast Grid SDK beta users, we’ve updated the Ultrafast Grid API, and it is now fully compatible with the original Selenium API. There should be no change in the tests when working with the Ultrafast Grid, if you already have Selenium tests. The only thing required is creating the Ultrafast Grid Eyes type, which is done by providing a Runner in the constructor.
• Added the latest version of Root Cause Analysis (RCA) for handling inline styles and better performance.

• Full-page screenshot for iOS 12.x native apps
• Check region for both Android and iOS

• Automated Test Maintenance, described here
• API Key Management, described here

• Multiple bugfixes: check frame for modals, check region in frame.

• Bugfixes: check region in frame by coordinates caused “stale element exception”
• Ultrafast Grid support: Added missing API from Eyes Selenium

• First public version of Python Images

• Added support for using the Ultrafast Grid (this is currently in beta phase and is not yet supported in the Java4 SDK)

First public release of eyes-appium-java4 package.

Features:

• Full content capture capability for Android and iOS.
• Complete separation of Appium from the Selenium SDK, to avoid dependencies conflicts.

First public release of eyes-appium-java4 package.

Features:

• Full content capture capability for Android and iOS.
• Complete separation of Appium from the Selenium SDK, to avoid dependencies conflicts.

First public release of eyes-appium-java4 package.

Features:

• Full content capture capability for Android and iOS.
• Complete separation of Appium from the Selenium SDK, to avoid dependencies conflicts.

• Add support for self-signed certificates (e.g., for on-prem servers or communication via IDS / proxy).

• Add support for self-signed certificates (e.g., for on-prem servers or communication via IDS / proxy).

• Add support for self-signed certificates (e.g., for on-prem servers or communication via IDS / proxy).

• Add support for self-signed certificates (e.g., for on-prem servers or communication via IDS / proxy).

• Internal api changes

• Bugfix: Scroll root element issue.

• Bugfix: “Viewport Size” parameter was ignored.

• Bugfix: “Viewport Size” parameter was ignored.

• Bugfixes: Removed specific scripts when running with Appium.

• Bugfixes: Removed specific scripts when running with Appium.

• Bugfix: Scroll root element issues (frame switching and scrolling)
• Bugfix: Scrolling script.

• Internal refactoring

• Internal refactoring

• Internal refactoring

• bugfixes: DOM capture, ScrollRootElement issues

Java3 SDK is now maintained in 2 development linesּ, due to Selenium’s changes:

• Version 3.3x.x: compatible with Selenium client up to 3.14.0.
• Version 3.14x.x (yes, 141): compatible with Selenium 3.141.0 onwards.
• Multiple bugfixes (both 3.141.1 and 3.38.2): Jersey1x proxy, JBoss retries and running tests with Selenium and Images SDK within the same context

• Internal refactoring

• Root Cause Analysis, described here. This is a premium product that customers can evaluate for free in Q1, 2019 and can choose to add to their subscription after Q1.
• Clear indication of diffs outside the viewport
• Better support for mobile testing by showing device info

• Includes configuration object.

• Supports new Selenium 4.0 API (so, now all Eyes commands should be called with async-await, there is no more promise-factory).
• Maintains most API backwards compatibility (the main difference is that imports have changed, I will send an example test when the version is released).
• setSendDom enabled by default
• Separate Appium package (this will not be released yet, as there is a problem with Appium support in the selenium-4.0 package of Selenium, regardless of Eyes).

• SendDom enabled by default

Additional fixes from previous versions:

• Added Configuration object.
• AgentSetup now contains more relevant data.
• Fixed Eyes.Check(ICheckSettings[] settings) (a.k.a. “Check Many”) method.
• Fixed Parent command not implemented on some browsers.
• More information on TestResults, StepInfo.

• Supports new Selenium 4.0 API (so, now all Eyes commands should be called with async-await, there is no more promise-factory).
• Maintains most API backwards compatibility (the main difference is that imports have changed, I will send an example test when the version is released).
• setSendDom enabled by default
• Separate Appium package (this will not be released yet, as there is a problem with Appium support in the selenium-4.0 package of Selenium, regardless of Eyes).

• Includes multiple bugfixes (e.g., ignore regions location)
• setSendDom enabled by default

• Multiple bugfixes: batch init from config object, elements border handling, NPE if driver is closed, “isDisabled” functionality fix.

Allow user override of PositionProvider.

• Bugfix: Appium landscape orientation for iOS.
• PositionProvider is now public (preparation for user-override).

• Compatibility with Appium updates, to enable running native app tests.

• A fix for Angular JS

• Added proxy support.

Bugfix related to the publishing process of the package.

• Added workaround for BrowserStack’s “parentFrame is not implemented” bug.
• Bugfix: handling FF parent element XPATH bug.

• Bugfixes for mobile browsers.
• Better handling for region in nested frames.

• Added the ability to set SessionEventHandlers – hooks notifying start and finish of various actions (e.g., starting check-window, finish check-window). This is used when a product is wrapping the SDK and proxying all communications through it (for example, HPE SRF), so they can filter / batch display various commands.
• Syntax: eyes.addSessionEventHandler(new RemoteSessionEventHandler(logger, serverUrl, accessKey)
• You can check the ISessionEventHandler to see which events are implemented: https://github.com/applitools/eyes.sdk.java3/blob/master/eyes.common.java/src/main/java/com/applitools/eyes/events/ISessionEventHandler.java

• Added the ability to set SessionEventHandlers – hooks notifying start and finish of various actions (e.g., starting check-window, finish check-window). This is used when a product is wrapping the SDK and proxying all communications through it (for example, HPE SRF), so they can filter / batch display various commands.
• Syntax: eyes.addSessionEventHandler(new RemoteSessionEventHandler(logger, serverUrl, accessKey)
• You can check the ISessionEventHandler to see which events are implemented: https://github.com/applitools/eyes.sdk.java3/blob/master/eyes.common.java/src/main/java/com/applitools/eyes/events/ISessionEventHandler.java

• Bugfix: Image cropping when limits exceed now only crops visible region

• “Check many” functionality – the ability to specify multiple regions to be validated in a single API call (without re-taking full page screenshot for each one). See example here: https://github.com/applitools/eyes.sdk.java3/blob/master/eyes.selenium.java/src/test/java/com.applitools.eyes.selenium/TestFluentApi.java#L182-L189
• Bugfixes: Image cropping when limits exceed now only crops visible region, manual switch to frame fix, default for hiding scrollbars is “documentElement” again
• Appium: Check region for Android Native apps
• Appium: Multiple bug fixes

• Updated to match the new Eyes.Sdk core

• Added support for .Net Core 2.0 and .Net Standard 2.0
• Improved logging
• Improved documentation
• Improved parallelizability
• Bugfixes: scaling issues, InRegion

• Improved fluent API
• Added CheckRegion
• Added Target.Url
• Added ImagesCheckSettings.Region(Rectangle region)
• Added Eyes.SetTitle(string title)

• Added types for Typescript
• Added retry for long-request
• Bugfixes

• Updated to match the new Eyes.Sdk core

• Added reporting contexts
• Bugfixes

• Added HideCaret support (removes the caret from the page, as opposed to IgnoreCaret which ignores it in the image). Set to True by default.
• Reduced round-trips to Selenium Server
• Updated to use latest Eyes.Sdk core

• Added types for Typescript
• Added retry for long-request
• Bugfixes

• Added element stitching
• Bugfixes

• Added commands for preparing the build to be used with Eyes
• Improved performance and robustness (batch requests to rendering grid, retries on failure)
• Added capabilities for Firefox
• Option to get results as a Tap file
• Documentation: https://github.com/applitools/eyes.storybook

• Updated to match the new Eyes.Sdk core

• Visual Test Environments view
• Visual Test History view
• GitHub Enterprise integration
• Batch & Branch management
• Table Configuration manager
• API Update
• Details in this blog post

• Added support for ListView, GridView and RecycleView full-page screenshots

• UI Version Control
• New View: Apps & Tests
• New View: List View of Test Baselines
• Details in this blog post

• Bugfix: Calabash empty test report
• Bugfix: Android calabash support for additional resolution

• Bugfix: Safari rotation
• Bugfix: Appium driver loading

• Automatic environment variable grabbing
• Delete tests from tests results
• Appium bugfixes
• Ignore region out of bounds now only prints warning (no exception)
• Updated automatic cut provider for Safari mobile (including iPhoneX)
• Bugfix: Ignore regions

• Automatic environment variable grabbing
• Delete tests from tests results
• Appium bugfixes
• Ignore region out of bounds now only prints warning (no exception)
• Updated automatic cut provider for Safari mobile (including iPhoneX)

• GitHub Integration
• Visual Studio Team Services Integration
• Details in this blog post

• Performance improvement: skips storybook by default (can be overridden using "skipStorybookBuild": false in the applitools config, or adding --build to the script)
• Logs are replaced with progress bar by default (and can be activated by adding --verbose / --debug to the script)
• Does not return exit code by default (thus avoiding node’s verbosity at the end of the run). Exit code can be forced by adding --exitcode to the script

• Added Fluent interface
• Added “withStatusBar” option for when the status bar is required
• Made the SDK agnostic to the type of initialization method used for XCUIApplication. Instead, the user should now provide the application instance they created using the “testApplication” parameter. We added a fallback for backwards compatibility – if the parameter was not provided, we use the default init method as before.
• Added “saveDiffs” option, and automatic environment variables identification:
  APPLITOOLS_API_KEY
APPLITOOLS_BATCH_NAME
APPLITOOLS_BATCH_ID
APPLITOOLS_BRANCH
APPLITOOLS_BASELINE_BRANCH
APPLITOOLS_PARENT_BRANCH

• Additional bugfixes

• Fixed setting ignore/floating regions when performing checkRegion

• Enabled CutProvider for the ImagesSDK
• Enabled override of the CutProvider for the Selenium version
• scrollToRegion can now be enabled/disabled in the fluent interface

• View Applitools Eyes test results and manage baselines directly from your TFS build report

Bugfixes for Protractor

• Improved performance and stability
• maxBrowsers configuration option for limiting concurrency was renamed to maxConcurrency

• iOS: viewport screenshot, specific region, and full page for TableView
• Android: viewport screenshot, specific region, full page for ScrollView

• Complete rewrite of the editor
• Thumbnails now open in the same tab, you can use ctrl/cmd + click / middle-click to view the step in a new tab
• You can now draw regions on the Viewer
• You can now use the browser’s back/forward buttons to navigate through the app
• Sidebar can now be resized
• Rejecting passed steps turns them red
• Added a team/role indicator to the navbar
• The Playback cursor in the editor can now be dragged, showing a preview thumbnail
• Improvements to chat
• Performance boost

• Viewport size related fixes

• Added ICutProvider
• Bugfixes

• Fluent interface similar to the standard Java SDK
• Users should use the following dependencies in their build.gradle file:
  compile ‘com.applitools:eyes-android-espresso:1.4.0@aar’
  compile ‘com.applitools:eyes-android-common:1.4.0’
  compile ‘com.applitools:eyes-android-core:1.4.0’

• Bugfixes

• Added fluent API

• Bugfix when handling user-provided viewport size for check-image

• Images SDK for iOS XCTest released!
• Available now on Cocoapods: https://libraries.io/cocoapods/EyesImages
• Tutorial:
  Swift: https://applitools.com/tutorials/xcui-swift.html
  Objective-C: https://applitools.com/tutorials/screenshots-xctest-objective-c.html

• React Storybook SDK released!
• Available now on npm: https://www.npmjs.com/package/@applitools/eyes.storybook
• Tutorial: https://applitools.com/tutorials/storybook-react.html

• Bugfixes

• Automatic header cropping for iOS Safari
• Bugfixes

• Bugfixes

• Bugfixes

• Allow override of entire page size by explicit user settings

• Allowing images SDK to be used inside a browser (for relevant testing environments)

• Calling “open” no longer requires viewport size, the first image size will be used by default

• Bugfixes related to check region inside frames

• SDK now throws DiffsFoundException instead of TestFailedException for new tests

• SDK now throws DiffsFoundException instead of TestFailedException for new tests

• SDK now throws DiffsFoundException instead of TestFailedException for new tests

• SDK now throws DiffsFoundException instead of TestFailedException for new tests

• SDK now throws DiffsFoundException instead of TestFailedException for new tests

• SDK now throws DiffsFoundException instead of TestFailedException for new tests
• Bugfixes in viewportsize for Appium and checkregion for Web

• Bugfix in frame handling

• New batch summary dashboard
• Ability to assign tests to users
• Ability to star tests and steps
• Users can add remarks on tests
• Improved the passed/failed test resolution criteria
• Ability to reset a saved session to its last saved state
• Admin panel will show an ‘inactive’ status for users with no activity logged over 6 months

• Fixed the handling of userAgent for Appium native apps
• Bugfixes

• Implemented updated connectivity method for avoiding arbitrary connection timeouts

• Implemented updated connectivity method for avoiding arbitrary connection timeouts

• Added fluent interface
• Bugfixes

• Bugfixes

• Bugfixes

• checkRegionInFrame backwards compatibility

• Bugfixes

• Added clearProperties()
• CutProvider backwards compatibility fix

• Added clearProperties()
• CutProvider backwards compatibility fix

• Fixed invalid offsets in checkRegion
• Compatibility with Appium native apps

• Added ability to take screenshots with popup dialogs eyes.checkWindowAllLayers(tag);

• Bugfixes

• Fixed handing of new Firefox frames
• Maven dependencies changed to be compatible with the latest Maven

• Added option to ignore caret in inputs: eyes.setIgnoreCaret(true);

• Added option to ignore caret in inputs: eyes.ignoreCaret = YES

• test-scope eyes.setIgnoreCaret() available

• Fixed setServerUrl method

• test-scope eyes.setIgnoreCaret() available
• Bugfix: appium drive class casting fix
• Image stitching overlap is now configurable via eyes.setStitchOverlap()

• Added Target.window().fully()
• Fixed setServerUrl method
• Bugfixes related to ElementFinder in protractor: allowed click to be called on an element

• Bugfixes

• Added target region by element/selector to the fluent API
• Added ignore/floating regions by element/selector
• Bugfixes

• Added compatibility with XCode 9 beta

• Jira integration
• Step changes (accept/reject, adding regions, etc) are now saved automatically without affecting the baseline
• Clicking the save button will only update the baseline

• Added ignore/floating region by selector
• Bugfixes

• Added custom properties support
• Bugfixes

• Pipeline support available:

  node {
      stage('Applitools build') {
          Applitools() {
              sh 'mvn clean test'
          }
      }
  }

  More information available at https://wiki.jenkins.io/display/JENKINS/Applitools+Eyes+Plugin

• Fluent API: Match level per step, ignore/floating regions directly from code. Examples can be found here: https://github.com/applitools/eyes.sdk.java3/blob/master/eyes.selenium.java/src/test/java/com.applitools.eyes.selenium/TestFluentApi.java
• Bugfixes

• Added API for specifying floating regions
• Support for padding ignore regions specified by element locators
• Bugfixes

• EyesXCUI is publicly available in Cocoapods: http://cocoapods.org/pods/EyesXCUI
• Added custom properties support
• Bugfixes

• Improved filters functionality and usability
• Added more filter options, custom properties included
• Added resolution statistics, showing your progress in reviewing the test results
• Added a quick filter menu for each Step
• Added ability to rename batches
• Added ability to preview the Baseline image in the step thumbnail
• Step Viewer can now show regions and annotations
• Added side-by-side comparison in the Step Viewer
• Added persistence to the Step Viewer’s zoom modes and visible layers (diffs, regions, etc)
• If diffs are hidden, they will do a quick flicker when navigating between steps in the Step Viewer
• Added new Fill zoom level
• Custom property values can now be seen in the Step Viewer, under ‘show more’
• Added a new Welcome page

• Added support for Custom Properties

• Protractor compatibility with our new fluent interface
• Bugfixes

• eyes.Open immediately opens a new session
• Bugfixes

• eyes.Open immediately opens a new session
• Bugfixes

• eyes.Open immediately opens a new session
• Bugfixes

• Multiple bugfixes: compatibility with Android 7 & 5.1
• Initial version uploaded to JCenter

• XCUI now supports full page screenshot for TableView

• Reduced memory footprint
• Added support for custom properties
• Protractor compatibility fixes
• Added support for different match level (strict, layout, etc) per check_window. Example can be found here: https://github.com/astappev/Eyes.Selenium.JavaScript/blob/8b7a28a831f9ce8bf8f2c335a3f52f8a02b755b4/test/check-interface-test.js#L46
• Bugfixes

• Added support for custom properties
• Specify Ignore/Floating regions via the SDK. An example can be found here: https://github.com/applitools/eyes.selenium.python/blob/master/samples/test_script.py

• Added support for Strict, Content and Layout baseline regions
• Direct link to test results (as provided by the SDK) now opens the test details view with the target test steps visible
• Test results within a batch can be grouped together by custom properties defined via the SDK
• Clicking a diff with CTRL / COMMAND pressed adds an ignore region that covers it
• Ignore regions can be programmatically defined via the SDK
• Different steps of a test can have different match levels

• Added screenshot trimming support
• Bugfixes

• Namespace change to Applitools.Selenium (breaking change)
• Added support for Fluent API (eyes.Check)
• Added support for additional DOM structures (for example, Frame(...).Frame(...).Region(...) is now supported)
• Separated Appium to a NuGet of its own

• Floating region appears disabled when matching with Layout
• Added TESTS filter to batch steps and batch steps by test views
• When hovering over the step details (current or baseline) the viewport (the area visible above the fold) is drawn on the image.
• Baseline details correctly show the details of the baseline against which the test is compared with rather than the baseline where baseline updates will be saved. Also, the branch of the baseline is now also included in the details.
• Added “what’s new” entry to the user menu
• The “Getting started” menu item leads to the new getting started page
• Remarks and issues view will not be the default view when launching the test manager

• Added support for Fluent API (eyes.Check)

• Eyes->open(...) now starts the session (this will be backported to other SDKs as well)
• Updated the documentation to support type hinting, used by PHPStorm and other IDEs
• composer.json updated to better support versioned dependencies, both required and suggested (for example, PHPUnit is only a suggested requirement, as it is not used by the SDK itself)

• Initial release

• A check command with fluent interface for defining visual validations
• The ability to define ignore and floating regions from within the code

• Includes the checkFrame variants found in the Java

• Updated namespacing
• Added includes check_frame/element/region

• CSS Stitching for Python is now available

• Moved to a uniform image scaling algorithm
• NuGet package now depends on 3rd party packages instead of including their dlls

• Fixed a bug that prevented multiple check window calls
• Moved to a uniform image scaling algorithm
• NuGet package now depends on 3rd party packages instead of including their dlls

• Support for full-page screenshots using either scrolling or CSS transformations
• Moved to a uniform image scaling algorithm
• NuGet package now depends on 3rd party packages instead of including their dlls

• Added ability to check the entire contents of a frame or a region within a frame
• Fixed checking of page regions
• Moved to a uniform image scaling algorithm
• NuGet package now depends on 3rd party packages instead of including their dlls

• Moved to a uniform image scaling algorithm
• NuGet package now depends on 3rd party packages instead of including their dlls

• Hide differences, regions, issues and remarks on test step images in the Test Editor
• Deleted comments and issues now appear as "deleted" and can be restored
• Improved UI performance when handling large test batches

• Added eyes.check command with fluent interface. An example can be found here: https://github.com/applitools/eyes.sdk.ruby/blob/master/examples/checkframeandelementfluentinterfaceexample.rb#L27-L28
• Added “match_single” which allow running a single-step test with a single web request. An example can be seen here: https://github.com/applitools/eyes.sdk.ruby/blob/master/examples/imagessingleexamplefiscript.rb#L17-L24
• Bugfixes
• Performance improvements

• Alpha: Add full page or element visual verification steps to your Selenium Builder tests

• Fixed edge case in setViewportSize that could result with a livelock

• Supports Selenium version 3.1 and up
• Support Ruby 2.4

• Added support for public teams which automatically register all visitors as viewers
• Regions can be moved and resized with the keyboard
• Added a keyboard shortcut cheat-sheet available in the user menu
• Tests and batches can be filtered by their start date

• Add full page visual checkpoints to your Espresso tests

• Add visual checkpoints to your XCUI tests

• Tests can be organized in custom hierarchies in the test list view
• Clicking a test in the test list view with CTRL key pressed opens it in the Test Editor
• Batch details show the total number of test in the batch

• Click a test in the test details view now shows its steps as thumbnails instead of opening it in the Test Editor

• View Applitools Eyes test results and manage baselines directly from your TeamCity build report [https://plugins.jetbrains.com/plugin/9441-applitools-eyes]

• Report issues and chat with team members directly from your test results [https://www.youtube.com/watch?v=IF6Gjq5DRUQ]
• New Admin panel
• Layout matching algorithm replaced by the Layout2 algorithm
• Test failed exception URL now leads to the test steps view of the test manager instead of the test editor
• Test results can be sorted by any test property in the test list view
• Move to the next and previous step without closing the step viewer

• Fixed broken setviewportsize on Firefox

• Image compression no longer crashes when the validated image is not a PNG image

• Image compression no longer crashes when the validated image is not a PNG image

• setViewportSize supports <100% Windows desktop zoom

• setViewportSize supports <100% Windows desktop zoom

• setViewportSize supports <100% Windows desktop zoom
• Switched to a uniform high-quality image scaling algorithm