# Install required packages
pip install selenium
pip install webdriver-manager

# For AI-based healing (optional)
pip install opencv-python
pip install pillow

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.service import Service
import json

class SelfHealingElement:
    """
    A wrapper for Selenium elements with self-healing capabilities
    """
    
    def __init__(self, driver, locator_strategies):
        """
        Initialize with multiple locator strategies
        
        Args:
            driver: Selenium WebDriver instance
            locator_strategies: List of tuples (By type, locator value)
        """
        self.driver = driver
        self.locator_strategies = locator_strategies
        self.successful_locator = None
        self.healing_log = []
    
    def find_element(self):
        """
        Try each locator strategy until element is found
        Returns the WebElement or raises exception
        """
        # Try the last successful locator first (optimization)
        if self.successful_locator:
            try:
                element = self.driver.find_element(*self.successful_locator)
                return element
            except NoSuchElementException:
                self.healing_log.append(f"Primary locator failed: {self.successful_locator}")
        
        # Try all locator strategies
        for by_type, locator_value in self.locator_strategies:
            try:
                element = self.driver.find_element(by_type, locator_value)
                
                # Element found - update successful locator
                if self.successful_locator != (by_type, locator_value):
                    self.healing_log.append(
                        f"Healed! New locator: {by_type}='{locator_value}'"
                    )
                    self.successful_locator = (by_type, locator_value)
                
                return element
                
            except NoSuchElementException:
                continue
        
        # No locator worked
        raise NoSuchElementException(
            f"Self-healing failed. Tried {len(self.locator_strategies)} strategies."
        )
    
    def save_healing_report(self, filename="healing_report.json"):
        """Save healing events to a file for analysis"""
        with open(filename, 'w') as f:
            json.dump(self.healing_log, f, indent=2)

from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time

def test_checkout_with_self_healing():
    """
    Test the checkout process with self-healing locators
    """
    # Initialize driver
    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
    driver.get("https://practiceautomatedtesting.com/shop")
    driver.maximize_window()
    
    # Define self-healing element for "Add to Cart" button
    # Multiple strategies increase resilience
    add_to_cart_button = SelfHealingElement(
        driver,
        locator_strategies=[
            (By.ID, "product-addtocart-button"),
            (By.CSS_SELECTOR, "button.action.primary.tocart"),
            (By.XPATH, "//button[@title='Add to Cart']"),
            (By.CSS_SELECTOR, "button[type='submit'][title='Add to Cart']"),
            (By.XPATH, "//button[contains(text(), 'Add to Cart')]")
        ]
    )
    
    # Navigate to first product
    first_product = driver.find_element(By.CSS_SELECTOR, ".product-item-link")
    first_product.click()
    time.sleep(2)
    
    # Use self-healing element
    button = add_to_cart_button.find_element()
    button.click()
    
    # Define self-healing element for cart icon
    cart_icon = SelfHealingElement(
        driver,
        locator_strategies=[
            (By.CSS_SELECTOR, "a.action.showcart"),
            (By.XPATH, "//a[@class='action showcart']"),
            (By.CSS_SELECTOR, ".minicart-wrapper a"),
            (By.XPATH, "//header//a[contains(@class, 'showcart')]")
        ]
    )
    
    # Verify cart updated
    cart_element = cart_icon.find_element()
    cart_count = cart_element.find_element(By.CSS_SELECTOR, ".counter-number")
    
    assert int(cart_count.text) > 0, "Cart should contain items"
    
    # Save healing report
    add_to_cart_button.save_healing_report("add_to_cart_healing.json")
    cart_icon.save_healing_report("cart_icon_healing.json")
    
    print("✅ Test passed with self-healing!")
    print(f"Healing events: {len(add_to_cart_button.healing_log)}")
    
    driver.quit()

# Run the test
test_checkout_with_self_healing()

class AttributeBasedHealing(SelfHealingElement):
    """
    Enhanced self-healing using element attributes and properties
    """
    
    def __init__(self, driver, locator_strategies, reference_attributes=None):
        super().__init__(driver, locator_strategies)
        self.reference_attributes = reference_attributes or {}
    
    def find_element_by_attributes(self):
        """
        Find element by matching multiple attributes
        More resilient than single locator strategies
        """
        # Get all elements that could be candidates
        all_elements = self.driver.find_elements(By.XPATH, "//*")
        
        best_match = None
        highest_score = 0
        
        for element in all_elements:
            score = 0
            
            # Score based on attribute matches
            for attr, expected_value in self.reference_attributes.items():
                try:
                    actual_value = element.get_attribute(attr)
                    if actual_value and expected_value in actual_value:
                        score += 1
                except:
                    continue
            
            # Update best match
            if score > highest_score:
                highest_score = score
                best_match = element
        
        if best_match and highest_score >= len(self.reference_attributes) * 0.6:
            self.healing_log.append(
                f"Found element by attributes (score: {highest_score})"
            )
            return best_match
        
        return None
    
    def find_element(self):
        """Try standard locators first, then attribute-based healing"""
        try:
            return super().find_element()
        except NoSuchElementException:
            # Try attribute-based healing as fallback
            element = self.find_element_by_attributes()
            if element:
                return element
            raise

# Usage example
search_button = AttributeBasedHealing(
    driver,
    locator_strategies=[
        (By.ID, "search-button"),
        (By.CSS_SELECTOR, "button.search-submit")
    ],
    reference_attributes={
        "type": "submit",
        "title": "Search",
        "aria-label": "Search"
    }
)

import json
from datetime import datetime

class HealingReporter:
    """Generate reports on self-healing events"""
    
    def __init__(self):
        self.healing_events = []
    
    def add_event(self, element_name, old_locator, new_locator, timestamp=None):
        """Record a healing event"""
        event = {
            "element": element_name,
            "old_locator": str(old_locator),
            "new_locator": str(new_locator),
            "timestamp": timestamp or datetime.now().isoformat(),
            "status": "healed"
        }
        self.healing_events.append(event)
    
    def generate_summary(self):
        """Print summary of healing events"""
        print("\n" + "="*50)
        print("SELF-HEALING TEST SUMMARY")
        print("="*50)
        print(f"Total healing events: {len(self.healing_events)}")
        
        if self.healing_events:
            print("\nHealing Details:")
            for i, event in enumerate(self.healing_events, 1):
                print(f"\n{i}. Element: {event['element']}")
                print(f"   Old: {event['old_locator']}")
                print(f"   New: {event['new_locator']}")
                print(f"   Time: {event['timestamp']}")
        
        print("="*50 + "\n")
    
    def export_to_json(self, filename="healing_report.json"):
        """Export report to JSON file"""
        with open(filename, 'w') as f:
            json.dump({
                "summary": {
                    "total_events": len(self.healing_events),
                    "report_date": datetime.now().isoformat()
                },
                "events": self.healing_events
            }, f, indent=2)
        print(f"Report saved to {filename}")

# Usage in tests
reporter = HealingReporter()

# When healing occurs
reporter.add_event(
    element_name="Login Button",
    old_locator=(By.ID, "old-login-btn"),
    new_locator=(By.CSS_SELECTOR, "button.login-new")
)

reporter.generate_summary()
reporter.export_to_json()

$ python self_healing_test.py

==================================================
SELF-HEALING TEST SUMMARY
==================================================
Total healing events: 2

Healing Details:

1. Element: Add to Cart Button
   Old: By.ID='product-addtocart-button'
   New: By.CSS_SELECTOR='button.action.primary.tocart'
   Time: 2024-01-15T10:30:45.123456

2. Element: Cart Icon
   Old: By.CSS_SELECTOR='a.action.showcart'
   New: By.XPATH='//header//a[contains(@class, 'showcart')]'
   Time: 2024-01-15T10:30:48.789012

==================================================

✅ Test passed with self-healing!
Healing events: 2
Report saved to healing_report.json

# ❌ WRONG: Too many locators slow down tests
element = SelfHealingElement(driver, [
    (By.ID, "button-1"),
    (By.CSS_SELECTOR, "#button-1"),
    (By.XPATH, "//*[@id='button-1']"),
    (By.XPATH, "//button[@id='button-1']"),
    (By.CSS_SELECTOR, "button#button-1"),
    # ... 10 more strategies
])

# ✅ CORRECT: 3-5 diverse strategies
element = SelfHealingElement(driver, [
    (By.ID, "button-1"),
    (By.CSS_SELECTOR, "button.primary-action"),
    (By.XPATH, "//button[@type='submit']"),
    (By.XPATH, "//button[contains(text(), 'Submit')]")
])

# ❌ WRONG: Creating new self-healing element each time
for i in range(10):
    button = SelfHealingElement(driver, strategies)
    button.find_element().click()

# ✅ CORRECT: Reuse self-healing element
button = SelfHealingElement(driver, strategies)
for i in range(10):
    button.find_element().click()

# ✅ BEST PRACTICE: Always review and update tests
def test_with_review():
    element = SelfHealingElement(driver, strategies)
    element.find_element().click()
    
    # Check if healing occurred
    if element.healing_log:
        print("⚠️ WARNING: Self-healing occurred!")
        print("Review and update test with new locator:")
        print(element.successful_locator)
        element.save_healing_report()

# ❌ WRONG: Using self-healing as excuse for poor locators
bad_element = SelfHealingElement(driver, [
    (By.XPATH, "//div[1]/div[2]/button[3]"),  # Fragile!
    (By.XPATH, "//div[1]/div[3]/button[2]"),  # Also fragile!
])

# ✅ CORRECT: Use semantic locators as primary strategy
good_element = SelfHealingElement(driver, [
    (By.CSS_SELECTOR, "[data-testid='submit-button']"),  # Stable!
    (By.ID, "submit-btn"),
    (By.CSS_SELECTOR, "button[type='submit']")



---

## Hands-On Practice

# EXERCISE

## Hands-On Exercise: Building a Basic Self-Healing Test Script

### Objective
Create a simple self-healing test automation script that can adapt to minor UI changes in a web application.

### Task
You'll build a test that logs into a demo application and implements basic self-healing capabilities using multiple locator strategies and retry logic.

### Prerequisites
- Python 3.x installed
- Selenium WebDriver installed (`pip install selenium`)
- Chrome browser and ChromeDriver

### Step-by-Step Instructions

#### Step 1: Set Up Your Environment
Create a new Python file called `self_healing_test.py`

#### Step 2: Implement Multiple Locator Strategy
Create a function that attempts to find an element using multiple locator strategies:

**Starter Code:**
```python
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, NoSuchElementException
import time

class SelfHealingTest:
    def __init__(self):
        self.driver = webdriver.Chrome()
        self.wait = WebDriverWait(self.driver, 10)
    
    def find_element_with_fallback(self, locators):
        """
        Attempts to find element using multiple locator strategies
        locators: list of tuples [(By.ID, "value"), (By.XPATH, "value"), ...]
        """
        # TODO: Implement logic to try each locator
        # Return the element if found, raise exception if all fail
        pass
    
    def smart_click(self, locators):
        """
        Click element with retry logic and multiple locators
        """
        # TODO: Implement click with fallback strategies
        pass
    
    def test_login(self):
        # TODO: Navigate to a demo site and test login with self-healing
        pass
    
    def cleanup(self):
        self.driver.quit()

# Run the test
if __name__ == "__main__":
    test = SelfHealingTest()
    try:
        test.test_login()
        print("✅ Test passed with self-healing!")
    except Exception as e:
        print(f"❌ Test failed: {e}")
    finally:
        test.cleanup()

def find_element_with_fallback(self, locators):
    for locator_type, locator_value in locators:
        try:
            element = self.wait.until(
                EC.presence_of_element_located((locator_type, locator_value))
            )
            print(f"✓ Found element using {locator_type}: {locator_value}")
            return element
        except TimeoutException:
            print(f"✗ Failed with {locator_type}: {locator_value}, trying next...")
            continue
    raise NoSuchElementException("Element not found with any locator strategy")

def smart_click(self, locators, retries=3):
    for attempt in range(retries):
        try:
            element = self.find_element_with_fallback(locators)
            element.click()
            print(f"✓ Successfully clicked element")
            return
        except Exception as e:
            print(f"Retry {attempt + 1}/{retries}: {e}")
            time.sleep(1)
    raise Exception("Failed to click after all retries")

def test_login(self):
    self.driver.get("https://practicetestautomation.com/practice-test-login/")
    
    # Username field with multiple locator strategies
    username_locators = [
        (By.ID, "username"),
        (By.NAME, "username"),
        (By.XPATH, "//input[@type='text']")
    ]
    username = self.find_element_with_fallback(username_locators)
    username.send_keys("student")
    
    # Password field
    password_locators = [
        (By.ID, "password"),
        (By.NAME, "password"),
        (By.XPATH, "//input[@type='password']")
    ]
    password = self.find_element_with_fallback(password_locators)
    password.send_keys("Password123")
    
    # Submit button
    submit_locators = [
        (By.ID, "submit"),
        (By.XPATH, "//button[@type='submit']"),
        (By.CLASS_NAME, "btn")
    ]
    self.smart_click(submit_locators)
    
    # Verify login success
    time.sleep(2)
    assert "Logged In Successfully" in self.driver.page_source