Ohhnews

分类导航

$ cd ..
DZone Java原文

如何构建自动生成Java版Selenium WebDriver测试的AI智能体：测试自动化工程师实用指南

#ai智能体#selenium#测试自动化#java#提示工程

人工智能正在通过实现更快的测试创建、更智能的执行和更高效的质量保证流程，改变软件测试。借助 AI 智能体，我们可以用最少的人工投入生成测试用例和脚本、运行测试并生成详细报告。AI 智能体 是代表用户利用人工智能达成目标并执行任务的软件系统。它们能够思考问题、规划行动并记住信息，同时还能自主决策并随时间改进。在本教程中，我们将构建一个正好能做到这一点的 AI 驱动智能体。它接收一个包含用简明英语编写的简单用例的 .txt 文件，使用 OpenAI 或 Ollama 等 AI 模型处理它，并生成 Java 编写的 Selenium 测试自动化脚本。

我们将构建一个用于测试自动化的 AI 智能体，它将执行以下任务：

  1. 从 .txt 文件读取测试场景
  2. 根据配置文件中选定的提供商，将场景连同合适的提示词发送给 OpenAI/Ollama
  3. 生成 Selenium WebDriver Java 测试自动化脚本，并拆分为：
  • 页面对象类
  • 测试类
  • testng.xml
  • 包含说明和运行测试步骤的 README.md

前置条件

开始构建用于测试自动化的 AI 智能体需要以下前置条件：

  • Python 3.14 及以上
  • 代码编辑器（推荐 VS Code）
  • 对 Python 和终端有基本了解
  • 用简明英语文本编写的测试场景

LLM 设置

  1. OpenAI API 密钥
  2. 在本地机器上设置 Ollama

理解 Selenium AI 测试生成工作流

在深入构建 AI 智能体之前，我们先从高层了解这个 AI 智能体如何生成 Selenium Java 测试自动化脚本：

[LOADING...]

下面逐步解释该过程：

  1. 用户输入：用户在 .txt 文件中提供用简明英语编写的测试场景。
  2. 处理层：Python 主脚本读取测试场景文件，并根据配置将其转发给 LLM 模型（OpenAI 或 Ollama）。
  3. AI 引擎：在向 LLM 发送请求之前，AI 智能体会将测试场景从简明英语转换为结构化提示词，并添加明确指令，例如：
  • 用 Java 生成 Selenium WebDriver 代码
  • 使用 TestNG 框架
  • 遵循页面对象模型
  • 生成多个页面对象类（如需要）
  • 生成代码的规则
  • 文件输出格式

LLM 理解测试描述、步骤和预期行为，并将其转换为相应的文件。

  1. 文件生成：AI 智能体创建一个基于时间戳的新文件夹，并将生成的代码存储到不同文件中，分别拆分为页面对象类、测试类、testng.xml 和 README.md。
.
├── config.py
├── tools.py
├── main.py
├── requirements.txt
├── .env
├── test_cases/
│   ├── input/
│   │   └── sample_test_case.txt
│   └── output/

[LOADING...]

让我们按照以下分步指南开始构建 AI 智能体：

步骤 1：创建并激活 Python 虚拟环境

在终端中运行以下命令创建 Python 虚拟环境：

$ bash
python -m venv venv

接下来，运行以下命令激活虚拟环境：

在 MacOS/Linux 上：

$ bash
source venv/bin/activate

在 Windows 上：

$ bash
venv\Scripts\activate

步骤 2：安装依赖

我们来创建 requirements.txt，因为它就像一份蓝图，用于重建运行项目所需的精确环境，从而在不同环境中保持一致。

#requirements.txt
openai==2.28.0
requests==2.32.5
python-dotenv==1.2.2

应从终端运行以下命令来安装依赖：

$ bash
pip install -r requirements.txt

[LOADING...]

步骤 3：编写配置文件

配置文件保存与 OpenAI、Ollama、输入和输出文件相关的详细信息，以及使用所需 LLM 提供商生成测试自动化脚本的设置。

$ python
#config.py
from dataclasses import dataclass, field
from pathlib import Path
from dotenv import load_dotenv
from dotenv import load_dotenv
from openai import OpenAI
import os

load_dotenv()

@dataclass
class OpenAIConfig:
    model_name: str = os.getenv("OPENAI_MODEL_NAME", "gpt-5")
    max_tokens: int = int(os.getenv("OPENAI_MAX_TOKENS", "4096"))
    temperature: float = float(os.getenv("OPENAI_TEMPERATURE", "0.3"))
    api_key: str = os.getenv("OPENAI_API_KEY", "")

    @property
    def client(self):
        if not self.api_key:
            raise ValueError(
                "OPENAI_API_KEY is required when using OpenAI provider"
            )
        return OpenAI(api_key=self.api_key)

@dataclass
class OllamaConfig:
    model: str = os.getenv("OLLAMA_MODEL_NAME", "llama3")
    prompt: str = "You are a Selenium WebDriver test automation expert. Generate Selenium WebDriver Java test scripts. STRICTLY follow the format. Any deviation is not acceptable."
    stream: bool = False
    temperature: float = float(os.getenv("OLLAMA_TEMPERATURE", "0.3"))
    ollama_baseurl:str = os.getenv("OLLAMA_BASEURL", "http://localhost:11434")
    ollama_endpoint: str = os.getenv("OLLAMA_ENDPOINT", "http://localhost:11434/api/generate")

@dataclass
class FileConfig:
    input_file: Path = Path("test_cases/input/sample_test_case.txt")
    output_file_path: Path = Path("test_cases/output/")

@dataclass
class AppConfig:
    provider:str = "ollama" #openai or ollama
    openai: OpenAIConfig = field(default_factory=OpenAIConfig)
    ollama: OllamaConfig = field(default_factory=OllamaConfig)
    files: FileConfig = field(default_factory=FileConfig)

config = AppConfig()

配置文件作为集中式配置系统，用于在 LLM 提供商之间切换并管理文件设置。下面我们分解一下以便进一步理解：

  • 数据类：@dataclass 会自动生成 __init__() 方法，使创建和管理对象更容易，无需编写样板代码。
  • 独立配置：为 OpenAI、Ollama 以及输入/输出文件处理分别定义了配置类，每个类都有默认值。输入文件名当前配置为 sample_test_case.txt。
  • AppConfig：AppConfig 类作为中心包装器，可通过一个标志在提供商（OpenAI 或 Ollama）之间切换。
  • field(default_factory=...)：它确保每个配置都有自己的实例，避免共享状态问题。

步骤 4：实现用于读取和生成代码的工具函数

在这一步中，我们将创建一个名为 tools.py 的新 Python 文件，并在其中实现以下工具函数：

  • load_test_case_from_file()
  • build_prompt()
  • generate_with_openai()
  • generate_with_ollama()
  • generate_selenium_test_script()
  • create_timestamped_output_dir()
  • split_and_save_files()

应在 tools.py 文件中导入以下包：

$ python
import requests
from config import config
from typing import Optional
from pathlib import Path
from datetime import datetime
from logger import logger
import requests
from config import config
from logger import logger

我们逐个学习这些工具函数。

load_test_case_from_file() 函数：

$ python
def load_test_case_from_file(file_path: str | Path) -> str:
    logger.info(f"Loading test case from: {file_path}")
    try:
        with open(file_path, "r", encoding="utf-8") as file:
            content = file.read()
            logger.info(f"Test case loaded successfully ({len(content)} characters)")
            return content
    except FileNotFoundError:
        logger.error(f"Test case file not found: {file_path}")
        raise FileNotFoundError(f"Test case file not found: {file_path}")
    except Exception as e:
        logger.exception(f"Error reading test case file: {e}")
        raise RuntimeError(f"Error reading test case file: {e}")

load_test_case_from_file() 函数以测试用例文件路径为参数，读取其内容并以字符串形式返回。它安全地处理错误：如果文件未找到，会抛出清晰的消息；并将任何其他意外问题包装为 RuntimeError。

build_prompt() 函数：

$ python
def build_prompt(use_case_text: str) -> str:
    logger.info("Building AI prompt")
    prompt = f"""
    You are a test automation expert specializing in Selenium WebDriver with Java.
    Generate Selenium automation test script using the following instructions and skills:
    - Use Java 17 to write the code
    - Use latest Selenium WebDriver Java dependency version to write code
    - Do not write code statement "System.setProperty()" to add chromedriver path, in the tests
    - Follow Page Object Model (POM)
    - Use latest version of TestNG dependency
    - Apply best coding practices for writing Java code
    - Add comments explaining each step
    - Add assertions using TestNG assertion
    - Do not add random assertion statements in the code
    - Do not mention any text in README that says that ChromeDriver path should be added to the Path
    - Never use brittle XPATH and CSS Selectors selectors such as .btn-primary, .container > div:nth-child(2), #content div span, or auto-generated classes.

    IMPORTANT: You MUST follow the exact output format below.

    Rules:
    - ALWAYS start each file with ===FILE: filename===
    - Use class names based on the web page(e.g. HomPage.java, LoginPage.java, etc. These names are for instructions only, use class name specific to the web page)
    - Do not add "Page" to the test class name
    - Do NOT add explanations outside file blocks
    - DO NOT skip this format
    - If you do not follow this format, the output will be rejected
    - DO NOT use markdown (no **, no ``` blocks)
    - DO NOT add file names outside ===FILE: markers
    - ONLY use ===FILE: filename=== format
    - OUTPUT FORMAT FOR FILES(STRICT):
      ===FILE: filename===
      file content
    - The following files MUST only be generated in the same order(STRICT). No deviation is acceptable:
      - Multiple Page Object classes(if needed) (Strictly Page object class, no WebDriver instantiation in these classes, Do not create duplicate page object classes)
      - Test class(WebDriver should be instantiated in the Test class, Do not use WebDriverManager to instantiate WebDriver, Use TestNG's @BeforeMethod annotation and define a method to instantiate the WebDriver, Use TestNG's @AfterMethod to quit the WebDriver)
      - Add assertions using TestNG assertion
      - Do not add random assertion statements in the code
      - testng.xml(Follow correct structure as per TestNG guidelines)
      - README.md (Include notes and steps to run the test using testng.xml file)
    Use Case:
    {use_case_text}
    """
    logger.info(f"Prompt created ({len(prompt)} characters)")
    return prompt

build_prompt() 函数是应用程序的核心部分，因为它构造发送给 LLM 的提示词，以生成 Selenium Java 测试自动化代码。它以用例文本为输入，并将其嵌入详细的指令模板中，引导模型使用 POM 和 TestNG 等最佳实践生成基于 Java 的 Selenium 测试。该提示词还强制执行文件格式规则，如 (===FILE: filename===)，以确保输出结构化、一致，并可直接用于生成文件而无需手动清理。它还强制按严格顺序生成 POM、测试类、testng.xml 和 README，以保持输出一致。

使用有效的提示词

有效的提示词对于使用 AI 生成干净、可靠的 Selenium 测试脚本至关重要。通过清晰定义需求，可以引导模型使用最佳编码实践、创建干净的测试脚本，并使用 页面对象模型（POM）生成结构良好的代码。

为更好的 Selenium Java 测试设计提示词

清晰、具体的提示词有助于 AI 生成更干净的 Selenium 测试脚本。提及使用 Java 编写 Selenium、使用最新版本的 Selenium 和 TestNG、遵循编码最佳实践等细节，以便 AI 更好地满足需求并生成设计良好的输出。

为页面对象模型（POM）自定义提示词

以下提示词可用于训练 AI 生成我们需要的页面对象文件：

  1. 使用最佳实践生成页面对象类。
  2. 生成多个页面对象类（如需要）。
  3. 不要在页面对象类中实例化 WebDriver。
  4. 不要创建重复的页面对象类。
  5. 此外，我们还可以提到使用最佳定位器策略，例如优先使用 ID 和 CSS 选择器而不是复杂的 XPath，使测试更稳定、可读且易于维护。

generate_with_openai() 函数：

$ python
def generate_with_openai(prompt: str) -> Optional[str]:
    response = config.openai.client.chat.completions.create(
        model=config.openai.model_name,
        temperature=config.openai.temperature,
        max_tokens=config.openai.max_tokens,
        messages=[
            {"role": "system", "content": "You are a Selenium WebDriver test automation expert. Generate Selenium WebDriver Java test scripts. STRICTLY follow the format. Any deviation is not acceptable."},
            {"role": "user", "content": prompt},
        ],
    )
    return response.choices[0].message.content

generate_with_openai() 函数向 OpenAI API 发送提示词，以生成 Java 编写的 Selenium WebDriver 测试脚本。OpenAI 客户端使用环境变量中的 API 密钥初始化，使代码能够安全地连接和交互 OpenAI 服务。它使用配置中的模型、温度和令牌限制。它生成请求时包含一条定义 AI 角色的消息和用户提示词（这里将提供 build_prompt() 函数的结果）。API 返回多个选择，函数从第一个响应中提取生成内容。最后，它将生成的测试脚本作为字符串返回。

generate_with_ollama() 函数：

$ python
def generate_with_ollama(prompt: str) -> str:
    logger.info(
        f"Generating test code with Ollama model: {config.ollama.model}"
    )
    response = requests.post(
        config.ollama.ollama_endpoint,
        json={
            "model": config.ollama.model,
            "prompt": config.ollama.prompt + "\n" + prompt,
            "stream": config.ollama.stream,
        },
    )
    response.raise_for_status()
    data = response.json()
    generated_text = data.get("response", "")
    logger.info(
        f"Ollama generation completed ({len(generated_text)} characters)"
    )
    return generated_text

generate_with_ollama() 函数通过向配置的 Ollama API 端点发送 POST 请求来生成文本。它将预定义的基础提示词与用户提供的提示词组合起来，并连同模型名称和流式配置一起发送。收到响应后，raise_for_status() 检查 HTTP 错误，response.json() 将响应解析为 Python 字典。生成的文本从 response 字段中提取，如果该字段缺失则使用空字符串。最后，函数记录响应长度并返回生成的文本。

generate_selenium_test_script() 函数：

$ python
def generate_selenium_test_script(test_case_text: str) -> Optional[str]:
    logger.info("Starting Selenium test generation")
    prompt = build_prompt(test_case_text)
    provider = config.provider.lower()
    logger.info(f"Using AI provider: {provider}")
    if provider == "openai":
        logger.info("Sending prompt to OpenAI")
        return generate_with_openai(prompt)
    elif provider == "ollama":
        logger.info("Sending prompt to Ollama")
        return generate_with_ollama(prompt)
    else:
        logger.error(f"Unsupported provider: {provider}")
        raise ValueError(f"Unsupported provider: {provider}")

generate_selenium_test_script() 函数作为一个包装器，根据输入的测试用例生成 Selenium WebDriver 测试脚本。它首先使用 build_prompt(test_case_text) 函数构建提示词，为 LLM 准备输入。接下来，根据配置的提供商（即 OpenAI 或 Ollama），动态调用相应函数生成脚本。如果指定了不支持的提供商，它会抛出 ValueError，以防止意外行为。

create_timestamped_output_dir() 函数：

$ python
def create_timestamped_output_dir(base_output_path: Path) -> Path:
    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    output_dir = base_output_path / timestamp
    output_dir.mkdir(parents=True, exist_ok=True)
    logger.info(f"Created output directory: {output_dir}")
    return output_dir

create_timestamped_output_dir() 函数创建一个以当前日期和时间命名的新文件夹，因此每次运行都会获得自己唯一的输出目录。它确保该文件夹存在（如需要则创建），并返回其路径以保存文件。

split_and_save_files() 函数：

$ python
def split_and_save_files(generated_text: str, base_output_path: Path) -> None:
    sections = generated_text.split("===FILE:")
    if len(sections)<=1:
        logger.error("No structured files found in AI response")
        raise ValueError ("No Structured files found in AI response!")
    logger.info(f"Found {len(sections) - 1} generated files")
    pageobject_dir = base_output_path/"pageobjects"
    pageobject_dir.mkdir(parents=True, exist_ok=True)
    for section in sections[1:]:
        section = section.strip()
        parts = section.split("\n",1)
        raw_filename = parts[0].strip()
        filename = raw_filename.replace("===", "").strip().split()[0]
        content = parts[1].strip() if len(parts)>1 else ""
        content = content.split("===FILE:")[0].strip()
        if filename.endswith("Page.java"):
            file_path = pageobject_dir / filename
        else:
            file_path = base_output_path / filename
        logger.info(f"Writing file: {file_path}")
        with open(file_path, "w", encoding="utf-8") as f:
            f.write(content)
        logger.info(f"Created: {file_path} ({len(content)} characters)")

split_and_save_files() 函数接收 AI 生成的响应，并基于标记 (===FILE:) 将其拆分为多个文件。它提取每个文件名及其内容，然后将它们保存到适当的文件夹中。页面对象文件放入 pageobjects 目录，而测试类、testng.xml 和 README.md 文件放入主 output/ 文件夹。如果缺少预期结构，它会抛出错误，以避免保存不正确的输出。

步骤 5：编写主脚本将所有内容串联起来

在这一步中，我们将创建一个 main.py 文件，用于编排使用 AI 生成 Selenium 测试脚本的完整工作流：

$ python
import re
from tools import load_test_case_from_file, generate_selenium_test_script,split_and_save_files,create_timestamped_output_dir, check_llm_connection
from config import config
from pathlib import Path
from logger import logger

def main() -> None:
    try:
        logger.info("Starting Selenium AI Test Generator")
        if not check_llm_connection():
            logger.error(
                "❌ LLM connection check failed. "
                "Stopping test generation."
            )
            return
        input_file = config.files.input_file
        output_file_path = config.files.output_file_path
        run_output_dir = create_timestamped_output_dir(output_file_path)
        use_case_text = load_test_case_from_file(input_file)
        if not use_case_text:
            logger.error("Test case file is empty.")
            raise ValueError("Test case file is empty.")
        generated_output = generate_selenium_test_script(use_case_text)
        if not generated_output:
            logger.error("Failed to generate Selenium WebDriver Java test automation scripts.")
            raise RuntimeError("Failed to generate Selenium WebDriver Java test automation scripts.")
        split_and_save_files(generated_output,run_output_dir)
        logger.info(f"✅ All generated files saved successfully to {run_output_dir}")
    except Exception as e:
        logger.error(f"❌ Error occurred while generating output files: {e}")

if __name__ == "__main__":
    main()

main.py 文件是程序启动并管理从开始到结束生成 Selenium 测试脚本整个过程的地方。它读取输入测试用例文件，将测试用例发送给 AI 以生成自动化脚本，并生成带时间戳的输出文件夹。脚本生成后，它会将脚本拆分为多个文件并保存到适当的目录中。如果发生任何异常，它会捕获错误并打印消息“生成输出文件时发生错误”以及异常详细信息。

生成第一批测试脚本

让我们创建一个新的文本文件 sample_test_case.txt，并将其放在 input/ 文件夹中，包含以下测试场景，以使用我们创建的 AI 智能体生成 Selenium 测试脚本：

Title: Application Login scenario
Precondition: User is registered in the application.
Steps:
1. Open Chrome browser
2. Navigate to https://ecommerce-playground.lambdatest.io/index.php?route=account/login
3. Enter "Johndoe881@email.com" in the E-Mail Address field
4. Enter "Password@321" in the Password field
5. Click on the Login Button
5. Add an assert statement to check that "My Account" page is displayed.

配置和设置

使用 OpenAI

创建一个 .env 文件，并在其中添加你的 OpenAI API 密钥。此文件应始终保留在本地机器上，不应提交到远程仓库。

OPENAI_MODEL_NAME=
OPENAI_MAX_TOKENS=
OPENAI_TEMPERATURE=
OPENAI_API_KEY=

使用 Ollama

  • 下载并安装 Ollama。
  • 在终端中运行命令 ollama serve 启动 Ollama。
  • 通过运行命令 --- ollama pull qwen3:8b 拉取 Qwen3:8b 模型。

创建一个 .env 文件并在其中更新以下详细信息：

OLLAMA_MODEL_NAME=qwen3:8b
OLLAMA_TEMPERATURE=0.3
OLLAMA_ENDPOINT=http://localhost:11434/api/generate
OLLAMA_BASEURL=http://localhost:11434

在运行模型之前，确保 Ollama 在后台运行。打开终端并运行命令 ollama serve

注意：不需要显式运行模型。

运行 AI 智能体

打开终端并运行以下命令以生成测试脚本：

$ bash
python main.py

AI 智能体成功运行后，控制台应打印以下日志：

[LOADING...]

测试脚本应生成在 output/ 文件夹内新创建的 时间戳（YYYY-MM-DD_hh-mm-ss） 文件夹中：

[LOADING...]

审查生成的 Java Selenium 代码

让我们检查 output/ 文件夹中生成的每个文件，并审查代码，以验证它是否符合我们定义的测试场景，并遵循预期结构和最佳实践。

生成了以下页面对象类：

LoginPage.java

$ java
public class LoginPage {
    private WebDriver driver;

    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }

    public void navigateToLoginPage() {
        driver.get("https://ecommerce-playground.lambdatest.io/index.php?route=account/login");
    }

    public void enterEmail(String email) {
        driver.findElement(By.name("email")).sendKeys(email);
    }

    public void enterPassword(String password) {
        driver.findElement(By.name("password")).sendKeys(password);
    }

    public void clickLoginButton() {
        driver.findElement(By.xpath("//button[@type='submit']")).click();
    }
}

页面对象文件已正确生成，使用了名称和 XPath 定位策略，并创建了适当的方法来与页面上的相应 WebElements 交互。但是，缺少 import 语句，应添加这些语句以避免错误。此外，应检查定位器，并可以在该类中添加显式等待，以在定位元素时减少测试执行过程中的不稳定性。生成了以下测试类：LoginTest.java

$ java
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class LoginTest {
    private WebDriver driver;

    @BeforeMethod
    public void setup() {
        System.setProperty("webdriver.chrome.driver", "path_to_chrome_driver");
        driver = new ChromeDriver();
    }

    @AfterMethod
    public void teardown() {
        driver.quit();
    }

    @Test
    public void testLoginScenario() {
        LoginPage loginPage = new LoginPage(driver);
        loginPage.navigateToLoginPage();
        loginPage.enterEmail("Johndoe881@email.com");
        loginPage.enterPassword("Password@321");
        loginPage.clickLoginButton();

        WebElement myAccountPageTitle = driver.findElement(By.xpath("//h1[@class='page-title']"));
        Assert.assertTrue(myAccountPageTitle.isDisplayed(), "My Account page is not displayed");
    }
}

该测试类是根据所提供的提示生成的，并包含用于初始化和清理的 @BeforeMethod 和 @AfterMethod 注解。然而，它包含了 System.setProperty()，这可以移除，因为最新版本的 Selenium 不需要通过它来设置 ChromeDriver 路径。缺少 @AfterMethod 注解的导入语句，应该添加它。此外，myAccountPageTitle WebElement 可以移到一个单独的 MyAccount 页面对象类中，并且还应该验证其 XPath，以确保它指向页面上正确的元素。

Testng.xml

$ xml

一旦代码移到项目中，就应该更新限定类名。

README.md

$ md
**如何运行测试**
1. 安装 TestNG 框架和 Selenium WebDriver。
2. 将 Selenium ChromeDriver 可执行文件放在一个目录中，用该目录更新 `LoginTest.java` 中的 path_to_chrome_driver 变量。
3. 通过执行以下命令，使用 testng.xml 文件运行测试：`java -cp .;test-classes org.testng.TestNG testng.xml`
注意：用你实际的 ChromeDriver 可执行文件路径更新 path_to_chrome_driver 变量。

关于 ChromeDriver 可执行文件的步骤和运行 testng.xml 的命令可以移除，因为它们不准确。相反，可以在这里更新为通过右键单击 testng.xml 来运行它的步骤。

总体而言，AI 代理快速生成了测试代码，节省了人工工作，并提供了一个良好的起点。然而，在项目中使用之前，请审查、验证并完善代码。

使用 AI 代理时的最佳实践

在使用 AI 代理生成自动化代码时，应考虑以下最佳实践：

  • 提高提示质量以获得可靠的测试：清晰且详细的提示有助于 AI 生成稳定的测试脚本。提及框架名称、命名约定和编码标准等要求，以改进结构并避免错误。
  • 添加断言和验证：始终确保生成的测试包含适当的断言，以验证预期结果。这有助于确认应用程序行为正确，而不仅仅是执行操作。
  • 在执行前审查并重构生成的代码：在运行 AI 生成的代码之前，始终先审查它。重构有助于消除冗余、提高可读性，并使代码与项目标准保持一致。
  • 处理无效/空输入：在处理测试用例文件等输入之前，先验证它们。确保为空的或无效的数据添加适当的步骤和验证检查，以防止执行期间出现意外失败。
  • 集成 OpenAI API 错误处理：对 API 调用进行适当的错误处理有助于管理超时、速率限制或响应失败等问题。使用 try-catch 块并记录错误消息可以提高错误可读性。异常处理有助于用简单的语言解释错误消息，并使调试更容易。
  • 日志记录和调试技巧：在关键步骤添加日志有助于跟踪执行流程并快速识别问题。清晰的日志消息使调试更容易，尤其是在处理 AI 生成的输出和 API 调用时。

观看分步 YouTube 教程：如何构建一个 AI 代理来用 Java 生成 Selenium WebDriver 测试。

局限性与挑战

在使用 AI 代理生成测试脚本时，可能会遇到以下局限性和挑战：

  • AI 生成的脚本可能会失败：AI 生成的测试脚本可以作为一个起点，但当输入提示不清晰或缺少重要细节时，它们可能会失败。它们也可能因为动态元素、错误的 UI 假设或特定环境问题而失败。
  • 手动清理/选择器准确性：AI 生成定位器可能并不总是可靠或最优。始终审查并完善 AI 生成脚本中的定位器，优先使用 ID 或 CSS 选择器等稳定选项，而不是复杂的 XPath。
  • 测试维护和不稳定性考虑：如果 AI 生成的测试没有正确处理等待、动态内容或同步，它们可能会不稳定。添加适当的等待并改进测试设计可以减少不稳定性。随着应用程序的演进，需要定期维护以保持测试稳定。
  • 审查幻觉：AI 有时会生成不正确或不存在的方法、元素或逻辑。在执行之前仔细审查代码，以捕捉此类幻觉。根据实际应用程序行为进行验证，可确保测试准确且可用。

结论

要设计一个生成测试脚本的 AI 代理，需要创建一个包含清晰规则、结构化输出格式和严格指南的全面提示，以确保结果一致。同时，验证和完善生成的代码，并优雅地处理边缘情况和失败也很重要。这一切都取决于团队的决定；由于 AI 正在不断发展，设计一个生成测试自动化脚本的 AI 代理也可能是一种可行且灵活的方法，尤其是在定制和控制很重要的情况下。