[SpringIO2025] Taming Testing of AI apps by Alex Soto
Lecturer
Alex Soto is the Director of Developer Experience at Red Hat, a Java Champion, and an advocate for open-source software. With over 17 years in the tech industry, he specializes in Java development, software automation, and AI integration. Soto is a prolific author, having co-authored books like “Applied AI for Enterprise Java Developers” and “Quarkus Cookbook,” and he frequently speaks on testing, cloud-native applications, and AI challenges.
Abstract
This article examines the complexities of testing AI-integrated applications, addressing challenges like non-deterministic outputs, hallucinations, and bias. It discusses strategies for ensuring reliability, including synthetic data generation, evaluation metrics, and model-assisted testing. Drawing on practical examples, it highlights methodologies for validating both deterministic and probabilistic components, emphasizing the role of data scientists and robust testing frameworks in building trustworthy AI systems.
Challenges in Testing AI-Integrated Applications
Integrating large language models (LLMs) into applications introduces unique testing hurdles, primarily due to their non-deterministic nature. Responses from models like GPT or Grok vary even for identical inputs, complicating assertions. For instance, querying an image might yield “cat” one time and “kitten” another, rendering strict equality checks ineffective. This unpredictability stems from the probabilistic architecture of LLMs, which prioritize generating plausible answers over consistency.
Hallucinations exacerbate this: models may produce inconsistent outputs (e.g., “Alex is tall and short”), input-output mismatches (e.g., rude responses despite politeness prompts), or factually incorrect information (e.g., “the Earth is flat”). Such behaviors, akin to journalists offering opinions on unfamiliar topics, necessitate specialized testing to detect and mitigate risks.
Traditional testing paradigms falter here, as AI components act as “black boxes.” Developers must treat models as external services, focusing on integration points while acknowledging limited control over internal mechanics.
Strategies for Handling Non-Determinism and Hallucinations
To address non-determinism, employ evaluation metrics over binary pass/fail. Tools like Ragas compute faithfulness (alignment with context), answer relevance, and contextual precision. For example, in retrieval-augmented generation (RAG), Ragas assesses if responses accurately reflect retrieved documents, using scores from 0 to 1.
Synthetic data generation enhances testing realism. LLMs can create diverse datasets, simulating user inputs without privacy concerns. In a pet clinic demo, a model populates forms with realistic personas, verifying outputs against expectations.
For hallucinations, chain-of-thought prompting guides models toward reasoned responses, reducing errors. Assertions check for inconsistencies, such as ensuring polite outputs or factual accuracy via external verifiers.
Code for Ragas evaluation in Java:
import dev.langchain4j.rag.query.Query;
import io.ragas.RagasEvaluator;
RagasEvaluator evaluator = new RagasEvaluator();
Query query = new Query("What is Spring Boot?");
String response = model.generate(query);
double faithfulness = evaluator.evaluateFaithfulness(response, context);
assert faithfulness > 0.8;
This quantifies response quality, enabling threshold-based assertions.
Model-Assisted Testing and Integration Approaches
Leverage AI for test creation and execution. Tools like MCPlaywright use models to script browser interactions, generating tests dynamically. In the pet clinic example, prompts instruct models to navigate, fill forms with synthetic data, and verify tables, outputting pass/fail.
Involve data scientists early for model-specific insights, ensuring tests cover bias and drift. Test deterministic parts (e.g., API routing) separately from AI components, using mocks for isolation.
Be resource-conscious: unnecessary politeness in prompts wastes compute (e.g., “thank you” equates to energy for three water bottles). Focus on rude, direct interactions for efficiency.
Implications for Reliable AI Development
Testing AI apps demands a paradigm shift toward probabilistic validation, blending traditional unit tests with advanced evaluators. Synthetic data and model-assisted tools democratize realistic testing, but require strong testing fundamentals. As AI permeates critical systems, these strategies ensure fairness, safety, and robustness, mitigating risks like hallucinations in production.
Future directions include AI-driven test optimization, reducing human effort while enhancing coverage. Developers must balance innovation with rigor, treating AI as an enhancement rather than a core dependency.