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

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > ADK Agent Testing > ADK Agent Test Doubles - Fakes, Mocks, and Stubs

ADK Agent Test Doubles - Fakes, Mocks, and Stubs

Author: Venkata Sudhakar

ShopMax India's ADK agent test suite uses different kinds of test doubles to replace real dependencies: a stub returns a fixed response without caring how it is called, a mock verifies that the agent called a dependency in the expected way, and a fake is a lightweight working implementation of a real service. Choosing the right test double for each situation keeps tests fast, focused, and free from over-specification that breaks on harmless implementation changes.

In ADK agent testing: use stubs for read-only tool calls where the return value matters but the call count does not (e.g. order lookup); use mocks for write operations where the agent must call a specific method with specific arguments (e.g. sending a notification); use fakes for stateful services that need realistic behaviour across multiple calls (e.g. a session store or inventory cache). Spy objects record calls without changing behaviour - useful for logging assertions without breaking the real implementation.

The example below demonstrates all three test double types for ShopMax India: a stub for order lookup, a mock (call recorder) for the notification sender, and a fake for the inventory service. Each test uses the appropriate double for its verification goal.

import pytest

def make_order_stub(order_id="ORD-8001", status="Shipped", city="Hyderabad"):
    def stub(oid):
        return {"order_id": order_id, "status": status, "city": city}
    return stub

class NotificationMock:
    def __init__(self): self.calls = []
    def send(self, customer_id, message):
        self.calls.append({"customer_id": customer_id, "message": message})
    def assert_called_once_with(self, customer_id, message):
        assert len(self.calls) == 1
        assert self.calls[0]["customer_id"] == customer_id
        assert message in self.calls[0]["message"]

class FakeInventory:
    def __init__(self):
        self._stock = {"SKU-TV-001": 10, "SKU-PHONE-002": 0}
    def get_stock(self, sku): return self._stock.get(sku, 0)
    def reserve(self, sku, qty):
        if self._stock.get(sku, 0) >= qty:
            self._stock[sku] -= qty
            return True
        return False

def test_stub_returns_fixed_order():
    lookup = make_order_stub("ORD-8001", "Delivered", "Bangalore")
    result = lookup("ORD-8001")
    assert result["status"] == "Delivered"
    assert result["city"] == "Bangalore"

def test_mock_verifies_notification_sent():
    notifier = NotificationMock()
    notifier.send("CUST-201", "Your order ORD-8002 is Shipped.")
    notifier.assert_called_once_with("CUST-201", "ORD-8002")

def test_fake_inventory_tracks_state():
    inv = FakeInventory()
    assert inv.get_stock("SKU-TV-001") == 10
    assert inv.reserve("SKU-TV-001", 3) is True
    assert inv.get_stock("SKU-TV-001") == 7
    assert inv.reserve("SKU-PHONE-002", 1) is False

It gives the following output,

... (3 passed in 0.01s)

In production, ShopMax India should document which test double type is used in each test module and why - this makes it easy for new engineers to extend the suite correctly. Prefer fakes over mocks for stateful dependencies like inventory because mocks that verify call arguments become brittle when the agent refactors its internal call sequence. Reserve mocks for side effects like emails and SMS where the exact call is the observable behaviour, not just the state change that results from it.

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