AI-agenter · Lektion

Assertionsbaseret agenttest

Kontrol af tool calls, mellemliggende trin og slutoutputtets struktur.

Lektion 3 af 413 trin

Assertionsbaseret agenttest er en gratis AI-agenter-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI-agenter, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI-agenter-kurset indeholder 4 lektioner i alt.

Videre fra eksakt tekstsammenligning

Da LLM-uddata ikke er deterministiske, er det skrøbeligt at teste dem med assert response == 'exact text'. Skriv i stedet kontroller, der undersøger svarenes struktur og hensigt uden at afhænge af den nøjagtige formulering.

Kontrol af, om der blev foretaget værktøjskald

For agenter med funktionskald er den mest pålidelige kontrol at bekræfte, at agenten valgte at kalde det rigtige værktøj. Det er strukturelt og afhænger ikke af den nøjagtige formulering af LLM'ens tankeproces.

import json
from unittest.mock import patch, MagicMock

@patch('myagent.client.chat.completions.create')
def test_agent_calls_search_tool(mock_create):
    # Mock: agent decides to call search_web
    tool_call = MagicMock()
    tool_call.function.name = 'search_web'
    tool_call.function.arguments = json.dumps({'query': 'Python tutorials'})
    mock_create.return_value = MagicMock(
        choices=[MagicMock(message=MagicMock(tool_calls=[tool_call]))]
    )

    response = mock_create()  # simulating the agent call
    tc = response.choices[0].message.tool_calls

    assert tc is not None
    assert len(tc) > 0
    assert tc[0].function.name == 'search_web'

# --- demo: give unittest.mock.patch a real dotted path to patch ---
import sys
import types

_myagent = types.ModuleType('myagent')
_myagent.client = types.SimpleNamespace(
    chat=types.SimpleNamespace(completions=types.SimpleNamespace(create=lambda *a, **k: None))
)
sys.modules['myagent'] = _myagent

test_agent_calls_search_tool()
print('test_agent_calls_search_tool: PASS')

Kontrol af det korrekte værktøjsnavn

Ud over blot at kontrollere, at der findes værktøjskald, skal du kontrollere, at det specifikke værktøjsnavn svarer til forventningerne. Det afslører tilfælde, hvor agenten vælger det forkerte værktøj til en given forespørgsel.

import json
from unittest.mock import MagicMock

def extract_tool_calls(response) -> list:
    message = response.choices[0].message
    if not message.tool_calls:
        return []
    return [
        {
            'name': tc.function.name,
            'args': json.loads(tc.function.arguments)
        }
        for tc in message.tool_calls
    ]

# In a test:
# calls = extract_tool_calls(mock_response)
# assert calls[0]['name'] == 'get_weather'
# assert calls[0]['args']['city'] == 'Paris'
print('Tool name and argument assertions are the most reliable agent tests')

Kontrol af værktøjsargumenter

Når du har kontrolleret værktøjsnavnet, skal du kontrollere, at argumenterne er korrekte. Agenten skal ikke kun vælge det rigtige værktøj, men også udfylde det med de rigtige parametre fra brugerens anmodning.

import json
from unittest.mock import patch, MagicMock

@patch('myagent.client.chat.completions.create')
def test_weather_tool_gets_correct_city(mock_create):
    tool_call = MagicMock()
    tool_call.function.name = 'get_weather'
    tool_call.function.arguments = json.dumps({'city': 'Tokyo', 'unit': 'celsius'})
    mock_create.return_value = MagicMock(
        choices=[MagicMock(message=MagicMock(tool_calls=[tool_call]))]
    )

    response = mock_create()
    args = json.loads(response.choices[0].message.tool_calls[0].function.arguments)

    assert args['city'] == 'Tokyo'
    assert args.get('unit') in ['celsius', 'fahrenheit', None]  # flexible

# --- demo: give unittest.mock.patch a real dotted path to patch ---
import sys
import types

_myagent = types.ModuleType('myagent')
_myagent.client = types.SimpleNamespace(
    chat=types.SimpleNamespace(completions=types.SimpleNamespace(create=lambda *a, **k: None))
)
sys.modules['myagent'] = _myagent

test_weather_tool_gets_correct_city()
print('test_weather_tool_gets_correct_city: PASS')

Validering af uddata med JSON Schema

Når din agent returnerer struktureret JSON, skal du validere uddataene mod et JSON Schema for at sikre, at alle påkrævede felter er til stede og har de korrekte typer. Biblioteket jsonschema gør dette nemt.

# pip install jsonschema
import jsonschema

AGENT_RESPONSE_SCHEMA = {
    'type': 'object',
    'required': ['answer', 'sources', 'confidence'],
    'properties': {
        'answer': {'type': 'string', 'minLength': 1},
        'sources': {
            'type': 'array',
            'items': {'type': 'string', 'format': 'uri'}
        },
        'confidence': {'type': 'number', 'minimum': 0, 'maximum': 1}
    }
}

def test_agent_output_schema(agent_output: dict):
    try:
        jsonschema.validate(instance=agent_output, schema=AGENT_RESPONSE_SCHEMA)
        print('Schema validation passed')
    except jsonschema.ValidationError as e:
        raise AssertionError(f'Invalid agent output: {e.message}')

Kontrol af nøgleords tilstedeværelse

For tekstsvar, hvor den nøjagtige formulering varierer, skal du kontrollere, at centrale begreber eller ord forekommer i uddataene. Det er fleksibelt, men stadig meningsfuldt — agentens svar skal som minimum nævne de relevante termer.

def assert_keywords_present(text: str, keywords: list, require_all: bool = True):
    lower_text = text.lower()
    found = [kw.lower() in lower_text for kw in keywords]

    if require_all:
        missing = [kw for kw, f in zip(keywords, found) if not f]
        assert not missing, f'Missing keywords: {missing}'
    else:
        assert any(found), f'None of {keywords} found in: {text[:100]}'

# Tests
response = 'The capital city of France is Paris, located in western Europe.'
assert_keywords_present(response, ['paris', 'france', 'capital'])
print('All keywords present!')  # passes

assert_keywords_present(response, ['spain', 'france'], require_all=False)
print('At least one keyword present!')  # passes

Kontrol af svarformat: Typekontroller

Typekontroller er hurtige og pålidelige. Kontrollér, at agenten returnerer en dict og ikke None, at listefelter er lister, og at numeriske felter ligger inden for gyldige områder.

def test_agent_returns_valid_structure(agent_result):
    # Type checks
    assert isinstance(agent_result, dict), 'Result must be a dict'
    assert isinstance(agent_result.get('answer'), str), 'answer must be a string'
    assert isinstance(agent_result.get('steps'), list), 'steps must be a list'

    # Non-empty checks
    assert len(agent_result['answer']) > 0, 'answer must not be empty'
    assert len(agent_result['steps']) >= 1, 'must have at least one step'

    # Range checks
    confidence = agent_result.get('confidence', 0)
    assert 0.0 <= confidence <= 1.0, 'confidence must be 0-1'

print('Structural assertions are fast and reliable')

Kontrol af finish_reason

Feltet finish_reason fortæller, hvorfor modellen stoppede med at generere. En kontrol af det hjælper med at opdage problemer: 'stop' betyder et rent svar, 'tool_calls' betyder, at agenten vil kalde et værktøj, og 'length' betyder, at svaret blev afkortet.

from unittest.mock import MagicMock

def test_agent_stops_cleanly(mock_response):
    finish_reason = mock_response.choices[0].finish_reason
    assert finish_reason in ('stop', 'tool_calls'), \
        f'Unexpected finish_reason: {finish_reason}'

def test_no_truncation(mock_response):
    finish_reason = mock_response.choices[0].finish_reason
    assert finish_reason != 'length', \
        'Response was truncated — increase max_tokens'

# Example mock for a clean stop
mock = MagicMock()
mock.choices = [MagicMock(finish_reason='stop')]
test_agent_stops_cleanly(mock)
print('finish_reason: stop — clean termination')

Kontrol af antallet af trin i en løkke

En agent, der kører i en løkke, bør afslutte efter et rimeligt antal trin. Kontrollér, at agenten afslutter inden for et maksimalt antal gentagelser — det afslører uendelige løkker, som din vagt med max_iterations skal forhindre.

def test_agent_completes_in_bounded_steps(mock_agent):
    result = mock_agent.run('Search for the weather in Paris')

    # Agent should complete within 5 steps
    assert result['steps_taken'] <= 5, \
        f'Agent took too many steps: {result["steps_taken"]}'

    # Agent should produce a final answer, not exit on timeout
    assert result['status'] == 'completed', \
        f'Agent did not complete: {result["status"]}'

    assert result['answer'] is not None

print('Bounding step count prevents runaway agents from passing tests')

Parametrisering af tests for flere inddata

@pytest.mark.parametrize i pytest lader dig køre den samme test med mange forskellige inddata. Det er ideelt til at teste, om din agent sender forskellige forespørgselstyper videre til de korrekte værktøjer.

import pytest
from unittest.mock import patch, MagicMock
import json

@pytest.mark.parametrize('query,expected_tool', [
    ('What is the weather in Tokyo?', 'get_weather'),
    ('Calculate 15% of 200', 'calculator'),
    ('Search for Python books', 'web_search'),
    ('What time is it in Berlin?', 'get_time'),
])
@patch('myagent.client.chat.completions.create')
def test_agent_tool_routing(mock_create, query, expected_tool):
    tool_call = MagicMock()
    tool_call.function.name = expected_tool
    tool_call.function.arguments = json.dumps({'input': query})
    mock_create.return_value = MagicMock(
        choices=[MagicMock(message=MagicMock(tool_calls=[tool_call]))]
    )
    response = mock_create()
    actual = response.choices[0].message.tool_calls[0].function.name
    assert actual == expected_tool

Skriv tilpassede hjælpefunktioner til kontroller

Efterhånden som din testsuite for agenter vokser, kan du udtrække almindelige kontrolmønstre til hjælpefunktioner. Det gør tests kortere, mere læsbare og nemmere at vedligeholde, når agentens svarformat ændres.

import json

def assert_tool_called(response, tool_name: str, required_args: dict = None):
    message = response.choices[0].message
    assert message.tool_calls, 'Expected tool call but got plain text'
    names = [tc.function.name for tc in message.tool_calls]
    assert tool_name in names, f'Expected {tool_name}, got {names}'

    if required_args:
        for tc in message.tool_calls:
            if tc.function.name == tool_name:
                args = json.loads(tc.function.arguments)
                for key, val in required_args.items():
                    assert args.get(key) == val, \
                        f'Arg {key}: expected {val}, got {args.get(key)}'

# Clean test using the helper:
# assert_tool_called(response, 'get_weather', {'city': 'Paris'})

# --- demo ---
from unittest.mock import MagicMock

tool_call = MagicMock()
tool_call.function.name = 'get_weather'
tool_call.function.arguments = json.dumps({'city': 'Paris'})
response = MagicMock(choices=[MagicMock(message=MagicMock(tool_calls=[tool_call]))])

assert_tool_called(response, 'get_weather', {'city': 'Paris'})
print('assert_tool_called passed: agent called get_weather with city=Paris')

Videnstjek: Kontrolbaseret test af agenter

Test din forståelse af kontrolstrategier til agenttests.

Besvar den i den interaktive lektion

Opsamling: Kontrolbaseret test af agenter

Du har nu et komplet sæt kontrolværktøjer til agenttests:

Kontrollér, at tool_calls ikke er tomt, når agenten skal bruge et værktøj
Kontrollér det korrekte værktøjsnavn med tc.function.name == 'expected_tool'
Validér værktøjsargumenter ved at fortolke tc.function.arguments som JSON
Brug jsonschema.validate() til validering af strukturerede uddata
Brug kontroller af nøgleords tilstedeværelse til fleksible tekstkontroller
Kontrollér finish_reason og antallet af trin for agenter med løkker
Brug @pytest.mark.parametrize til scenarier med flere inddata

Gratis at komme i gang

Lær AI-agenter med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 60
Lektioner: 239

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Assertionsbaseret agenttest” gratis?

Ja — hele teksten til “Assertionsbaseret agenttest” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI-agenter-kurset, skal du opgradere til CoddyKit PRO. AI-agenter-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Assertionsbaseret agenttest”?

Kontrol af tool calls, mellemliggende trin og slutoutputtets struktur. Du øver dig i AI-agenter med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på AI-agenter?

Der kræves ingen tidligere erfaring. AI-agenter på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Assertionsbaseret agenttest”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne AI-agenter-lektion?

Ja. Alle AI-agenter-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til AI-agenter