将AI集成到测试自动化框架：ChatGPT API实践指南

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import java.net.http.*;
import java.net.URI;
import java.time.Duration;

public class OpenAIClient {
  private final HttpClient http = HttpClient.newBuilder()
      .connectTimeout(Duration.ofSeconds(20)).build();
  private final String apiKey;

  public OpenAIClient(String apiKey) { this.apiKey = apiKey; }

  public String chat(String userPrompt) throws Exception {
    String body = """
      {
        "model": "gpt-5-mini",
        "messages": [
          {"role":"system","content":"You are a helpful assistant for test automation..."},
          {"role":"user","content": %s}
        ]
      }
      """.formatted(json(userPrompt)); 
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://api.openai.com/v1/chat/completions"))
        .timeout(Duration.ofSeconds(60))
        .header("Authorization", "Bearer " + apiKey)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body))
        .build();

    HttpResponse<String> res = http.send(req, HttpResponse.BodyHandlers.ofString());
    if (res.statusCode() >= 300) throw new RuntimeException(res.body());
    return res.body();
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class TestUser { public String firstName, lastName, email, phone; public Address address; }
class Address { public String street, city, state, zip; }

public List<TestUser> generateUsers(OpenAIClient client, int count) throws Exception {
  String prompt = """
    You generate test users as STRICT JSON only.
    Schema: {"users":[{"firstName":"","lastName":"","email":"","phone":"",
    "address":{"street":"","city":"","state":"","zip":""}}]}
    Count = %d. Output JSON only, no prose.
  """.formatted(count);

  String content = client.chat(prompt);
  JsonNode root = new ObjectMapper().readTree(content);
  ArrayNode arr = (ArrayNode) root.path("users");
  List<TestUser> out = new ArrayList<>();
  ObjectMapper m = new ObjectMapper();
  arr.forEach(n -> out.add(m.convertValue(n, TestUser.class)));
  return out;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//Redaction middleware (keep it simple and fast)
public final class LogSanitizer {
  private LogSanitizer() {}
  public static String sanitize(String log) {
    if (log == null) return "";
    log = log.replaceAll("(?i)(api[_-]?key\\s*[:=]\\s*)([a-z0-9-_]{8,})", "$1[REDACTED]");
    log = log.replaceAll("([A-Za-z0-9-_]{20,}\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+)", "[REDACTED_JWT]");
    log = log.replaceAll("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+", "[REDACTED_EMAIL]");
    return log;
  }
}

//Ask for a structured verdict
record Verdict(String verdict, double confidence, List<String> reasons) {}

public Verdict analyzeLogs(OpenAIClient client, String rawLogs) throws Exception {
  String safeLogs = LogSanitizer.sanitize(rawLogs);

  String prompt = """
    You are a log-analysis assistant.
    Given logs, detect anomalies (errors, timeouts, stack traces, inconsistent sequences).
    Respond ONLY as JSON with this exact schema:
    {"verdict":"PASS|FAIL","confidence":0.0-1.0,"reasons":["...","..."]}
    Logs (UTC):
    ----------------
    %s
    ----------------
  """.formatted(safeLogs);

  // Chat with the model and parse the JSON content field
  String content = client.chat(prompt);
  ObjectMapper mapper = new ObjectMapper();
  JsonNode jNode = mapper.readTree(content);

  String verdict = jNode.path("verdict").asText("PASS");
  double confidence = jNode.path("confidence").asDouble(0.0);

  List<String> reasons = mapper.convertValue(
      jNode.path("reasons").isMissingNode() ? List.of() : jNode.path("reasons"),
      new com.fasterxml.jackson.core.type.TypeReference<List<String>>() {}
  );

  return new Verdict(verdict, confidence, reasons);
}