	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > ADK Agent Testing > Building an End-to-End ADK Agent Test Suite

Building an End-to-End ADK Agent Test Suite

Author: Venkata Sudhakar

A production-grade ADK agent test suite for ShopMax India combines unit tests, integration tests, and performance assertions in a single pytest file. Unit tests verify individual helper functions in isolation. Integration tests run the full agent pipeline with a mocked LLM. Performance tests check token budgets and response latency. Organising all three levels in one suite makes it easy to run the full check in a single pytest command during CI.

pytest fixtures centralise shared test state: shopmax_context holds the agent configuration and latency budgets, mock_llm returns a preconfigured AsyncMock with realistic token metadata, and sample_order_query provides a standard input string. Each test function declares only the fixtures it needs, keeping tests focused and independent without duplicating setup code.

The example below builds a complete ShopMax India agent test suite with six tests covering order ID extraction, token budget enforcement, response content, order ID presence in the reply, latency measurement, and empty query fallback handling.

import pytest
import asyncio
import re
import time
from unittest.mock import MagicMock, AsyncMock

@pytest.fixture
def shopmax_context():
    return {
        "business": "ShopMax India",
        "category": "order_tracking",
        "max_latency_ms": 200,
        "max_input_tokens": 500,
        "max_output_tokens": 150,
    }

@pytest.fixture
def mock_llm():
    llm = MagicMock()
    resp = MagicMock()
    resp.text = "Order ORD-7821 is shipped. Delivery by 26 Apr to Mumbai."
    resp.usage_metadata.input_token_count = 320
    resp.usage_metadata.output_token_count = 85
    llm.generate_content_async = AsyncMock(return_value=resp)
    return llm

@pytest.fixture
def sample_order_query():
    return "Track order ORD-7821 from Mumbai"

def extract_order_id(query):
    match = re.search(r"ORD-\d+", query)
    return match.group(0) if match else None

async def call_agent(query, llm):
    start = time.monotonic()
    result = await llm.generate_content_async(query)
    latency_ms = (time.monotonic() - start) * 1000
    return {
        "text": result.text,
        "input_tokens": result.usage_metadata.input_token_count,
        "output_tokens": result.usage_metadata.output_token_count,
        "latency_ms": latency_ms,
    }

def test_unit_order_id_extraction(sample_order_query):
    assert extract_order_id(sample_order_query) == "ORD-7821"

def test_token_budget(mock_llm, sample_order_query, shopmax_context):
    result = asyncio.run(call_agent(sample_order_query, mock_llm))
    assert result["input_tokens"] <= shopmax_context["max_input_tokens"]
    assert result["output_tokens"] <= shopmax_context["max_output_tokens"]

def test_response_not_empty(mock_llm, sample_order_query):
    result = asyncio.run(call_agent(sample_order_query, mock_llm))
    assert result["text"] and len(result["text"]) > 0

def test_response_contains_order_id(mock_llm, sample_order_query):
    result = asyncio.run(call_agent(sample_order_query, mock_llm))
    assert "ORD-7821" in result["text"], "Order ID missing from response"

def test_latency_within_budget(mock_llm, sample_order_query, shopmax_context):
    result = asyncio.run(call_agent(sample_order_query, mock_llm))
    assert result["latency_ms"] < shopmax_context["max_latency_ms"], (
        "Latency " + str(round(result["latency_ms"], 1)) + "ms exceeds budget"
    )

def test_empty_query_returns_fallback(mock_llm):
    fallback = MagicMock()
    fallback.text = "No information found."
    fallback.usage_metadata.input_token_count = 10
    fallback.usage_metadata.output_token_count = 5
    mock_llm.generate_content_async = AsyncMock(return_value=fallback)
    result = asyncio.run(call_agent("", mock_llm))
    assert result["text"] == "No information found."

It gives the following output,

...... (6 passed in 0.02s)

In production, extend the suite by adding a conftest.py that spins up a real InMemoryRunner for integration tests and keeps the mocked tests in a separate unit test file. Tag tests with pytest.mark.unit, pytest.mark.integration, and pytest.mark.performance so you can run each tier independently in CI. Make this suite the gate for every pull request touching the ShopMax India agent codebase so that regressions in token usage, response quality, or latency are caught before merge.

Send your comments, suggestions or queries regarding this site to [email protected].