AI-Assisted Selenium Testing

// Healenium: wrap the driver once, keep the rest of the suite unchanged
import com.epam.healenium.SelfHealingDriver;

WebDriver delegate = new ChromeDriver();
SelfHealingDriver driver = SelfHealingDriver.create(delegate);

// Uses normal locators. On NoSuchElementException, Healenium consults its
// stored DOM snapshots and substitutes the closest match, logging the change.
driver.findElement(By.id("place-order")).click();

// Healenium needs its backend (Docker) to store snapshots:
// docker compose up -d   (healenium-backend + postgres)

# No Healenium for Python; a lightweight fallback pattern gives 80% of the value.
from selenium.common.exceptions import NoSuchElementException

def find_with_fallback(driver, primary, *fallbacks):
  """Try the primary locator, then fallbacks in order; log which one worked."""
  for by, value in (primary, *fallbacks):
      try:
          el = driver.find_element(by, value)
          if (by, value) != primary:
              print(f"HEALED: {primary} -> {(by, value)}")
          return el
      except NoSuchElementException:
          continue
  raise NoSuchElementException(f"None of the locators matched: {primary}, {fallbacks}")

place_order = find_with_fallback(
  driver,
  (By.CSS_SELECTOR, "[data-testid='place-order']"),
  (By.ID, "place-order"),
  (By.XPATH, "//button[normalize-space()='Place order']"),
)

// Fallback pattern; logs when a secondary locator was needed
async function findWithFallback(driver, primary, ...fallbacks) {
for (const locator of [primary, ...fallbacks]) {
  const found = await driver.findElements(locator);
  if (found.length) {
    if (locator !== primary) console.warn('HEALED:', primary, '->', locator);
    return found[0];
  }
}
throw new Error(`None of the locators matched: ${primary}`);
}

const placeOrder = await findWithFallback(
driver,
By.css("[data-testid='place-order']"),
By.id('place-order'),
By.xpath("//button[normalize-space()='Place order']")
);

// Fallback pattern; logs when a secondary locator was needed
IWebElement FindWithFallback(IWebDriver driver, By primary, params By[] fallbacks)
{
  foreach (var locator in new[] { primary }.Concat(fallbacks))
  {
      var found = driver.FindElements(locator);
      if (found.Count > 0)
      {
          if (locator != primary) Console.WriteLine($"HEALED: {primary} -> {locator}");
          return found[0];
      }
  }
  throw new NoSuchElementException($"None of the locators matched: {primary}");
}

var placeOrder = FindWithFallback(driver,
  By.CssSelector("[data-testid='place-order']"),
  By.Id("place-order"),
  By.XPath("//button[normalize-space()='Place order']"));

// Wait for the page to settle, then capture the region you care about
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.cssSelector(".skeleton-loader")));
WebElement card = driver.findElement(By.cssSelector("[data-testid='pricing-table']"));
byte[] png = card.getScreenshotAs(OutputType.BYTES);

// Hand to your visual service (Applitools, Percy) or your own baseline comparison
visualService.check("pricing-table", png);

wait.until(EC.invisibility_of_element_located((By.CSS_SELECTOR, ".skeleton-loader")))
card = driver.find_element(By.CSS_SELECTOR, "[data-testid='pricing-table']")
png = card.screenshot_as_png

visual_service.check("pricing-table", png)

await driver.wait(until.elementIsNotVisible(await driver.findElement(By.css('.skeleton-loader'))), 10000);
const card = await driver.findElement(By.css("[data-testid='pricing-table']"));
const png = Buffer.from(await card.takeScreenshot(), 'base64');

await visualService.check('pricing-table', png);

wait.Until(d => !d.FindElements(By.CssSelector(".skeleton-loader")).Any(e => e.Displayed));
var card = driver.FindElement(By.CssSelector("[data-testid='pricing-table']"));
var png = ((ITakesScreenshot)card).GetScreenshot().AsByteArray;

visualService.Check("pricing-table", png);

// In a JUnit 5 extension or TestNG listener, on failure:
List<String> consoleErrors = new CopyOnWriteArrayList<>();
driver.script().addJavaScriptErrorHandler(e -> consoleErrors.add(e.getText()));

// ... test runs ...

Path dir = Path.of("evidence", testName);
Files.createDirectories(dir);
Files.write(dir.resolve("screenshot.png"), ((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES));
Files.writeString(dir.resolve("page.html"), driver.getPageSource());
Files.writeString(dir.resolve("console.txt"), String.join("\n", consoleErrors));
Files.writeString(dir.resolve("assertion.txt"), throwable.getMessage());
// Feed the folder to your triage prompt or attach to the CI report

# In a pytest fixture with autouse=True, after yield:
console_errors = []
driver.script.add_javascript_error_handler(lambda e: console_errors.append(e.text))

# ... test runs ...

evidence = Path("evidence") / test_name
evidence.mkdir(parents=True, exist_ok=True)
driver.save_screenshot(evidence / "screenshot.png")
(evidence / "page.html").write_text(driver.page_source)
(evidence / "console.txt").write_text("\n".join(console_errors))
(evidence / "assertion.txt").write_text(str(exc))

const consoleErrors = [];
await driver.script().addJavaScriptErrorHandler((e) => consoleErrors.push(e.text));

// ... test runs ... on failure:
const dir = path.join('evidence', testName);
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'screenshot.png'), await driver.takeScreenshot(), 'base64');
fs.writeFileSync(path.join(dir, 'page.html'), await driver.getPageSource());
fs.writeFileSync(path.join(dir, 'console.txt'), consoleErrors.join('\n'));
fs.writeFileSync(path.join(dir, 'assertion.txt'), err.message);

var consoleErrors = new ConcurrentBag<string>();
var bidi = await driver.AsBiDiAsync();
await bidi.Log.OnEntryAddedAsync(e => { if (e.Level == "error") consoleErrors.Add(e.Text); });

// ... test runs ... on failure:
var dir = Path.Combine("evidence", testName);
Directory.CreateDirectory(dir);
((ITakesScreenshot)driver).GetScreenshot().SaveAsFile(Path.Combine(dir, "screenshot.png"));
File.WriteAllText(Path.Combine(dir, "page.html"), driver.PageSource);
File.WriteAllText(Path.Combine(dir, "console.txt"), string.Join("\n", consoleErrors));
File.WriteAllText(Path.Combine(dir, "assertion.txt"), ex.Message);