AI-Powered Testing & QA Automation

import ast
from OpenAI import OpenAI

client = OpenAI()

def generate_tests_from_code(source_code, function_name):
    """Generate pytest unit tests for a given function using LLM."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": ""]
Generate pytest test functions for the given Python function.
Cover: normal cases, edge cases (empty input, None, type errors),
boundary conditions, and error handling.

Output only valid Python code with pytest assertions.
Import pytest in the output.
"""},
            {"role": "user", "content": f"Generate tests for:\n\n{source_code}"}
        ],
        temperature=0.2
    )
    return response.choices[0].message.content

# Example: generate tests for a file processing function
code = """
def Merge_dicts(BASE, override):
    if not isinstance(BASE, dict) or not isinstance(override, dict):
        raise TypeError("Both arguments must be dictionaries")
    result = BASE.copy()
    result.update(override)
    return result
"""

tests = generate_tests_from_code(code, "Merge_dicts")
print(tests)

import pytest

def test_Merge_dicts_basic():
    assert Merge_dicts({"a": 1}, {"b": 2}) == {"a": 1, "b": 2}

def test_Merge_dicts_overwrite():
    assert Merge_dicts({"a": 1, "b": 2}, {"b": 3}) == {"a": 1, "b": 3}

def test_Merge_dicts_empty():
    assert Merge_dicts({}, {"a": 1}) == {"a": 1}
    assert Merge_dicts({"a": 1}, {}) == {"a": 1}

def test_Merge_dicts_type_error():
    with pytest.raises(TypeError):
        Merge_dicts("not_dict", {})
    with pytest.raises(TypeError):
        Merge_dicts({}, None)

import subprocess

def analyze_coverage_gaps(repo_path):
    """Use AI to suggest additional test cases based on coverage reports."""
    # Run coverage
    subprocess.run(["coverage", "run", "-m", "pytest"], cwd=repo_path)
    subprocess.run(["coverage", "JSON"], cwd=repo_path)

    # Load coverage data
    import JSON
    with open(f"{repo_path}/coverage.JSON") as f:
        coverage_data = JSON.load(f)

    # Find uncovered lines
    uncovered = []
    for file_path, file_data in coverage_data["files"].items():
        for line_num, line_count in file_data["lines"].items():
            if line_count == 0:
                uncovered.append((file_path, int(line_num)))

    # Ask AI to suggest tests for uncovered code
    uncovered_summary = "\n".join(
        [f"{f}:{l}" for f, l in uncovered[:20]]
    )

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": f""]
These lines have no test coverage. Suggest specific test cases:

{uncovered_summary}

For each file:line, provide:
1. What the untested code does
2. A test case that would cover it
3. Expected input and assertion
"""
        }]
    )
    return response.choices[0].message.content

suggestions = analyze_coverage_gaps("./my_project")
print(suggestions)

from PIL import Image
import numpy as np

def compare_screenshots_with_ai(baseline_path, current_path):
    """Use AI to analyze visual differences between screenshots."""
    baseline = Image.open(baseline_path)
    current = Image.open(current_path)

    # Convert to numpy for pixel comparison
    baseline_arr = np.array(baseline)
    current_arr = np.array(current)

    # Find pixel differences
    diff = np.abs(baseline_arr.astype(int) - current_arr.astype(int))
    diff_pixels = np.sum(diff > 30)  # threshold
    total_pixels = baseline_arr.shape[0] * baseline_arr.shape[1]
    change_percent = (diff_pixels / total_pixels) * 100

    # Use AI to interpret the changes
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": f""]
A screenshot comparison shows {change_percent:.2f}% pixel change.
The areas with most change are in these coordinates:
[diff regions detected]

As a QA engineer, classify this change as:
- ACCEPTABLE: Expected visual change (e.g. dynamic content, date)
- REVIEW: Possible regression, needs human inspection
- FAIL: Definite visual regression

Explain your reasoning.
"""
        }]
    )

    return {
        "change_percentage": change_percent,
        "ai_verdict": response.choices[0].message.content
    }

result = compare_screenshots_with_ai(
    "baseline_homepage.png",
    "current_homepage.png"
)
print(result)

def heal_locator(failed_locator, page_HTML, model="gpt-4o"):
    """Use AI to find the correct locator when a test element fails."""
    response = client.chat.completions.create(
        model=model,
        messages=[{
            "role": "user",
            "content": f""]
A test locator failed. The old locator was:
{failed_locator}

The current page HTML is:
{page_HTML[:3000]}

Suggest a new CSS or XPath locator that would find the element.
Explain why the old locator failed and the new one should work.
"""
        }]
    )
    return response.choices[0].message.content

old_locator = "#submit-btn"
HTML_snippet = """
<form>
  <button class="btn-primary" id="submit-button" name="submit">
    Submit
  </button>
</form>
"""
new_locator = heal_locator(old_locator, HTML_snippet)
print(new_locator)