Auto Healing for Playwright Web Automation

---

The TestMu AI's Auto Healing feature for Playwright testing allows you to automatically recover from certain types of failures during the execution of your test scripts. When enabled, it can significantly enhance the robustness of your test suite by handling unexpected situations and errors, thereby reducing test flakiness and improving test reliability of your test suites.

Enabling Auto Healing

---

To enable the Auto Healing feature, you need to pass the autoHeal: true as a capability in your Playwright configuration. For example:

const capabilities = {
  browserName: "Chrome",
  browserVersion: "latest",
  "LT:Options": {
    platform: "Windows 10",
    build: "Playwright Auto Heal Build",
    name: "Playwright Auto Heal Test",
    user: process.env.LT_USERNAME,
    accessKey: process.env.LT_ACCESS_KEY,
    network: true,
    video: true,
    console: true,
    autoHeal: true,
  },
};

Note: There are no Prerequisites required for enabling the auto-healing feature. You can enable the auto-healing feature directly via desired capabilities.

Language Preferences:

---

JavaScript

For JavaScript/NodeJS, you can use the following code:

// playwright.config.js
module.exports = {
  use: {
    connectOptions: {
      wsEndpoint: `wss://cdp.lambdatest.com/playwright?capabilities=${encodeURIComponent(JSON.stringify({
        'browserName': 'Chrome',
        'browserVersion': 'latest',
        'LT:Options': {
          'platform': 'Windows 10',
          'build': 'Playwright Auto Heal Build',
          'name': 'Playwright Auto Heal Test',
          'autoHeal': true,
          'user': process.env.LT_USERNAME,
          'accessKey': process.env.LT_ACCESS_KEY,
        }
      }))}`
    }
  }
};

Python

For Python, you can use the following code:

import asyncio
from playwright.async_api import async_playwright

capabilities = {
    'browserName': 'Chrome',
    'browserVersion': 'latest',
    'LT:Options': {
        'platform': 'Windows 10',
        'build': 'Playwright Auto Heal Build',
        'name': 'Playwright Auto Heal Test',
        'autoHeal': True,
        'user': 'your_username',
        'accessKey': 'your_access_key',
    }
}

async def run():
    async with async_playwright() as playwright:
        browser = await playwright.chromium.connect(
            ws_endpoint=f"wss://cdp.lambdatest.com/playwright?capabilities={capabilities}"
        )

C#

For C#, you can use the following code:

using Microsoft.Playwright;

var capabilities = new Dictionary<string, object>()
{
    ["browserName"] = "Chrome",
    ["browserVersion"] = "latest",
    ["LT:Options"] = new Dictionary<string, object>()
    {
        ["platform"] = "Windows 10",
        ["build"] = "Playwright Auto Heal Build",
        ["name"] = "Playwright Auto Heal Test",
        ["autoHeal"] = true,
        ["user"] = Environment.GetEnvironmentVariable("LT_USERNAME"),
        ["accessKey"] = Environment.GetEnvironmentVariable("LT_ACCESS_KEY"),
    }
};

var browser = await Playwright.Chromium.ConnectAsync($"wss://cdp.lambdatest.com/playwright?capabilities={Uri.EscapeDataString(JsonSerializer.Serialize(capabilities))}");

Java

For Java, you can use the following code:

import com.microsoft.playwright.*;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> capabilities = new HashMap<>();
capabilities.put("browserName", "Chrome");
capabilities.put("browserVersion", "latest");

Map<String, Object> ltOptions = new HashMap<>();
ltOptions.put("platform", "Windows 10");
ltOptions.put("build", "Playwright Auto Heal Build");
ltOptions.put("name", "Playwright Auto Heal Test");
ltOptions.put("autoHeal", true);
ltOptions.put("user", System.getenv("LT_USERNAME"));
ltOptions.put("accessKey", System.getenv("LT_ACCESS_KEY"));

capabilities.put("LT:Options", ltOptions);

Browser browser = playwright.chromium().connect("wss://cdp.lambdatest.com/playwright?capabilities=" + URLEncoder.encode(new Gson().toJson(capabilities), "UTF-8"));

How Auto Healing Works

---

Playwright Locator's auto-healing is a sophisticated method in test automation designed to address the instability of inconsistent tests. This system smartly adjusts locators by merging attributes and context, ensuring robustness and adaptability. During runtime, it consistently monitors the web page to identify DOM (Document Object Model) alterations.

When an element is successfully located on the page using Playwright's locator methods (page.locator('#username').click(), etc.), its DOM path is recorded for subsequent use. If that same element is later referenced on the same page and is missing, the system evaluates the current page and formulates new locators for altered elements based on previous benchmarks.

Auto Detection of New Locator

---

In some scenarios, web elements might change their locators due to updates in the web application. However, the Auto Healing feature can automatically detect the new locator and continue the test execution.

Here is an example test case demonstrating this:

const { test } = require('../lambdatest-setup');
const { expect } = require('@playwright/test');

test.describe('Browse LambdaTest in different search engines', () => {
    test('Test Auto Heal', async ({ page }) => {
        await page.goto('https://www.lambdatest.com/selenium-playground/auto-healing');
        await page.waitForTimeout(1000); // sleep 1s

        // Locate element before DOM change
        let buttonBeforeDOMChange = await page.locator('#username'); // equivalent to FindElement ByID
        await buttonBeforeDOMChange.click();

        // Trigger DOM change
        await page.click('p.selenium_btn');
        await page.waitForTimeout(1000); // sleep 1s

        // Try to locate the same element after DOM change
        // Auto healing will automatically detect the new locator
        let buttonAfterDOMChange = await page.locator('#username'); // again check for element
        await buttonAfterDOMChange.click();

        await page.waitForTimeout(1000); // sleep 1s
    });
});

In the above test case, we are interacting with an element before and after a DOM change occurs on TestMu AI's auto-healing playground. The Auto Healing feature will automatically detect if the element's locator has changed and adapt accordingly, ensuring the test continues to execute successfully.

To run the test, execute the below command:

npx playwright test auto-heal.spec.js

Benefits Of Auto Healing

---

Self-healing plays a vital role in refining the Playwright test automation process. Here are its primary advantages:

1. Increased Test Stability: The auto-healing feature of TestMu AI ensures that Playwright tests remain consistent and stable, even when faced with minor changes in the web application's UI. By dynamically adjusting to these changes, the AI Native auto-healing feature overcomes test flakiness, providing stability and reliability to your test suite in no time.

2. Reduced Test Maintenance: One of the significant challenges in test automation is the constant need to update and maintain test scripts due to evolving application interfaces. With TestMu AI's auto-healing capability for Playwright, the system automatically adapts to these changes, reducing the manual effort required to update test scripts, and saving time and resources.

3. Intelligent Test Automation: TestMu AI's auto-healing feature is not just about adapting to changes; it's about doing so intelligently. The auto-healing feature adds intelligence to the automated Playwright tests and enables them to dynamically adapt to the changes in an application and its environment. It typically involves applying artificial intelligence and machine learning algorithms to the self-healing of tests.

4. Reliable CI/CD pipeline: Continuous Integration and Continuous Deployment (CI/CD) pipelines require reliable and consistent test results to ensure that the software development process is smooth and efficient. With the auto-healing feature, TestMu AI ensures that the Playwright tests feeding into the CI/CD pipeline are stable, reducing the chances of unexpected failures and ensuring a smoother development and deployment process.

Limitations of Auto Healing

---

While the Auto Healing feature is designed to handle a wide range of issues, there are certain limitations to be aware of:

• Non-recoverable errors: Auto Healing cannot recover from certain types of errors, such as Playwright browser initialization errors, network connectivity issues, or system-level failures.

• Test accuracy: While Auto Healing can reduce test flakiness, it may also mask real issues in your web application or test scripts. It's important to review the logs and understand why a test needed healing.

• Performance impact: While typically minimal, enabling Auto Healing can have a slight impact on test execution time due to the additional checks and recovery mechanisms.

• Limited scope: Auto Healing works best with simple locator changes (ID, class, attribute modifications) and may not be effective for complete page redesigns or fundamental workflow changes.

  The Auto Healing feature is a functionality to enhance the robustness of your Playwright test suite, but it does not replace good test design and error handling practices. Always ensure your tests are well-designed, have proper error handling in place, and are reviewed regularly for issues that may be masked by the Auto Healing feature.

---

That was all you need to know for the Auto-Healing feature with Playwright. If you still have any questions for us, please feel free to let us know. Our experts are always available on chat to help you out with any roadblock regarding our product. Happy testing!