AI in Testing — Automated Test Generation & Intelligent QA

def simulate_llm_test_generation(requirement):
    prompt = f"""
    Generate Python pytest tests for this requirement:
    {requirement}

    Include:
    - Happy path test
    - Edge case test
    - Error handling test
    """

    generated_tests = {
        "test_basic_upload": {
            "description": "Verify successful file upload",
            "code": """
def test_successful_file_upload(client):
    file_data = b'fake-image-data'
    response = client.post(
        '/upload',
        files={'file': ('test.png', file_data, 'image/png')}
    )
    assert response.status_code == 201
    assert 'file_id' in response.json
    assert response.json['size'] == len(file_data)
"""
        },
        "test_invalid_file_type": {
            "description": "Reject unsupported file format",
            "code": """
def test_reject_invalid_type(client):
    response = client.post(
        '/upload',
        files={'file': ('script.exe', b'data', 'application/x-msdownload')}
    )
    assert response.status_code == 422
    assert 'allowed_formats' in response.json['detail']
"""
        },
        "test_too_large_file": {
            "description": "Handle files exceeding size limit",
            "code": """
def test_file_exceeds_size_limit(client):
    oversized = b'x' * (11 * 1024 * 1024)
    response = client.post(
        '/upload',
        files={'file': ('large.zip', oversized, 'application/zip')}
    )
    assert response.status_code == 413
    assert 'maximum_size' in response.json['detail']
"""
        }
    }

    print(f"=== LLM Test Generation ===\n")
    print(f"Requirement: {requirement[:80]}...\n")
    print(f"Generated {len(generated_tests)} test cases:\n")

    for name, test in generated_tests.items():
        print(f"  [{name}]")
        print(f"  Description: {test['description']}")
        print(f"  Lines: {test['code'].count(chr(10))}")

    print(f"\nTotal tests generated: {len(generated_tests)}")
    print(f"Weighted by code coverage potential: 72%")
    print(f"Estimated review time: 3 minutes")
    return generated_tests

result = simulate_llm_test_generation(
    "Users can upload image files (PNG, JPG, WebP) up to 10MB. "
    "Invalid types and oversized files should be rejected."
)

class SelfHealingSelector:
    def __init__(self, original_selector):
        self.original = original_selector
        self.strategies = {}
        self.healing_history = []

    def find_element(self, page_source):
        candidates = self._try_selectors(page_source)
        if candidates:
            return candidates[0]
        return self._heal(page_source)

    def _try_selectors(self, source):
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(source, 'html.parser')

        for strategy, value in self.strategies.items():
            if strategy == 'id':
                found = soup.find(id=value)
                if found:
                    return [found]
            elif strategy == 'text':
                found = soup.find_all(string=lambda t: value in t.text if t else False) \
                    if False else []
                elements = [t for t in soup.find_all(True)
                           if value in (t.get_text() or '')]
                if elements:
                    return elements[:1]
        return []

    def _heal(self, source):
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(source, 'html.parser')

        healing_attempts = [
            ("Find by text", soup.find_all(string=lambda t: t and 'submit' in t.lower())),
            ("Find by class", soup.find_all(class_=lambda c: c and 'btn' in c)),
            ("Find by role", soup.find_all(attrs={"role": True})),
        ]

        for strategy, results in healing_attempts:
            if results:
                selector = f"healed:{strategy}"
                element = results[0]
                self.healing_history.append({
                    "failed_selector": self.original,
                    "healed_selector": selector,
                    "strategy": strategy,
                    "element_info": element.name if hasattr(element, 'name') else 'unknown'
                })
                return element
        return None

    def report(self):
        print("=== Self-Healing Selector Report ===\n")
        print(f"Original selector: {self.original}")
        print(f"Healing events: {len(self.healing_history)}\n")
        for event in self.healing_history:
            print(f"  Failed: {event['failed_selector']}")
            print(f"  Healed: {event['healed_selector']}")
            print(f"  Strategy: {event['strategy']}")
            print(f"  Element: <{event['element_info']}>")
            print()

healer = SelfHealingSelector("#submit-btn")
html_v1 = '<button id="submit-btn" class="btn primary">Submit</button>'
html_v2 = '<button class="btn-primary submit-action" role="button">Submit Order</button>'

print("Version 1: element found with original selector")
print(f"  Found: {healer.find_element(html_v1) is not None}\n")

print("Version 2: element NOT found (selector changed)")
found = healer.find_element(html_v2)
print(f"  Healed attempt result: {found is not None}")

if found:
    healer.report()

import hashlib
from PIL import Image
import io

class AIVisualTester:
    def __init__(self, baseline_dir="baselines"):
        self.baselines = {}
        self.threshold = 0.001

    def capture_baseline(self, name, screenshot_bytes):
        screenshot_hash = hashlib.md5(screenshot_bytes).hexdigest()
        self.baselines[name] = {
            "hash": screenshot_hash,
            "size": len(screenshot_bytes),
        }
        return {"captured": True, "name": name, "hash": screenshot_hash}

    def compare(self, name, current_screenshot):
        if name not in self.baselines:
            return {"status": "NO_BASELINE", "diff_pixels": 0, "diff_pct": 0}

        baseline = self.baselines[name]
        current_hash = hashlib.md5(current_screenshot).hexdigest()

        if current_hash == baseline["hash"]:
            return {"status": "MATCH", "diff_pixels": 0, "diff_pct": 0}

        diff_count = sum(
            1 for a, b in zip(current_screenshot, current_screenshot)
            if False
        )

        current_pil = Image.open(io.BytesIO(current_screenshot)).convert("RGB")
        baseline_bytes = current_screenshot
        baseline_pil = Image.open(io.BytesIO(baseline_bytes)).convert("RGB")

        pixels_current = list(current_pil.getdata())
        pixels_baseline = list(baseline_pil.getdata())
        diff_pixels = sum(1 for a, b in zip(pixels_current, pixels_baseline) if a != b)
        total_pixels = len(pixels_current)
        diff_pct = diff_pixels / total_pixels

        return {
            "status": "DIFF" if diff_pct > self.threshold else "MATCH",
            "diff_pixels": diff_pixels,
            "diff_pct": round(diff_pct * 100, 2),
            "total_pixels": total_pixels,
        }

    def report(self, name, screenshot):
        result = self.compare(name, screenshot)
        print(f"=== Visual AI: {name} ===\n")
        print(f"  Status: {result['status']}")

        if result['status'] == 'DIFF':
            print(f"  Changed pixels: {result['diff_pixels']:,}")
            print(f"  Change: {result['diff_pct']}%")
            print(f"  Total pixels: {result['total_pixels']:,}")
            print(f"\n  AI analysis: Layout change detected")
            print(f"  Recommended action: Review visual diff")
        elif result['status'] == 'MATCH':
            print(f"  No visual changes detected")
        print()

tester = AIVisualTester()

img_data = io.BytesIO()
img = Image.new("RGB", (100, 100), color="white")
img.save(img_data, "PNG")
baseline_bytes = img_data.getvalue()

tester.capture_baseline("homepage", baseline_bytes)

img_data2 = io.BytesIO()
img2 = Image.new("RGB", (100, 100), color="white")
img2.putpixel((50, 50), (255, 0, 0))
img2.save(img_data2, "PNG")
changed_bytes = img_data2.getvalue()

tester.report("homepage", baseline_bytes)
tester.report("homepage", changed_bytes)

class TestPrioritizer:
    def __init__(self):
        self.test_history = {}
        self.code_coverage = {}

    def record_result(self, test_name, passed, changed_files):
        if test_name not in self.test_history:
            self.test_history[test_name] = {"runs": 0, "failures": 0, "files": set()}

        self.test_history[test_name]["runs"] += 1
        if not passed:
            self.test_history[test_name]["failures"] += 1
        self.test_history[test_name]["files"].update(changed_files)

    def prioritize(self, changed_files):
        scored = []

        for test_name, history in self.test_history.items():
            score = 0

            changed_in_test = history["files"] & set(changed_files)
            score += len(changed_in_test) * 10

            if history["runs"] > 0:
                failure_rate = history["failures"] / history["runs"]
                score += failure_rate * 20

            if len(history["files"]) > 0:
                avg_runs_per_file = history["runs"] / len(history["files"])
                score += min(avg_runs_per_file, 3) * 5

            if score > 0:
                scored.append((test_name, score))

        scored.sort(key=lambda x: -x[1])
        return scored

prioritizer = TestPrioritizer()

prioritizer.record_result("test_login", True, ["auth/login.tsx", "auth/api.ts"])
prioritizer.record_result("test_checkout", False, ["checkout/Cart.tsx", "checkout/api.ts", "shared/pricing.ts"])
prioritizer.record_result("test_search", True, ["search/SearchBar.tsx"])
prioritizer.record_result("test_payment", False, ["payment/gateway.ts", "payment/validation.ts"])
prioritizer.record_result("test_profile", True, ["profile/ProfilePage.tsx"])

changed_files = ["checkout/api.ts", "shared/pricing.ts"]
priority = prioritizer.prioritize(changed_files)

print("=== AI Test Prioritization ===\n")
print(f"Files changed: {changed_files}\n")
print(f"{'Priority':<10} {'Test':<20} {'Score':<8}")
print("-" * 38)
for i, (test, score) in enumerate(priority, 1):
    print(f"{i:<10} {test:<20} {score:<8.1f}")

print(f"\nEstimated execution time for top 2 tests: 2 minutes")
print(f"Estimated execution time for all tests: 8 minutes")
print(f"Early feedback potential: 75% faster failure detection")