Lab Walkthrough Test Your Agent

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

import agent_components
from agent_components import check_calendar, execute_tool

class TestUnit(unittest.TestCase):
    def test_imports_and_callables(self):
        # Ensure the functions we've been using actually exist and are callable.
        self.assertTrue(callable(check_calendar))
        self.assertTrue(callable(execute_tool))

python3 -m unittest

class TestAgentLoop(unittest.TestCase):
    def test_tool_dispatch_on_tool_call(self):
        # Patch the execute_tool function on the agent_components module so we can assert it was called.
        with patch.object(agent_components, "execute_tool") as mock_execute_tool:
            fake_tool_call = MagicMock()
            fake_tool_call.function.name = "check_calendar"
            # The model often returns tool arguments as a JSON string.
            fake_tool_call.function.arguments = json.dumps({})

            # Simulate what your orchestration logic would extract from the model response.
            name = fake_tool_call.function.name
            args = json.loads(fake_tool_call.function.arguments or "{}")

            # Call the dispatch function (using the module reference to ensure we hit the patched function).
            agent_components.execute_tool(name, args)

            # Assert dispatch happened with the expected tool name and arguments.
            mock_execute_tool.assert_called_with("check_calendar", {})

class TestAgentEval(unittest.TestCase):
    def test_agent_responds_to_calendar_query(self):
        from openai import OpenAI

        # Expect an environment variable with the API key. Fail early with a helpful message if missing.
        api_key = os.environ.get("OPENAI_API_KEY")
        if not api_key:
            self.skipTest("OPENAI_API_KEY not set; skipping eval test")

        base = os.environ.get("OPENAI_API_BASE")

        # Create the client (include base_url only if provided).
        client_kwargs = {"api_key": api_key}
        if base:
            client_kwargs["base_url"] = base

        client = OpenAI(**client_kwargs)

        # Send a calendar-related user message and include the calendar tool definition that your agent uses.
        response = client.chat.completions.create(
            model="openai/gpt-4.1-mini",
            messages=[{"role": "user", "content": "What's on my calendar?"}],
            tools=[agent_components.CHECK_CALENDAR_TOOL],
        )

        choice = response.choices[0]

        # The model may indicate it wants to call a tool (finish_reason can vary across SDKs/versions),
        # or it may reply directly. Accept multiple common finish_reason values used for tool/function calls.
        made_tool_call = getattr(choice, "finish_reason", None) in ("tool_calls", "tool_call", "function_call")

        # Extract content safely from the returned choice. Some SDK versions expose .message, others provide dicts.
        content = ""
        if hasattr(choice, "message"):
            message = choice.message
            raw = getattr(message, "content", "") or ""
            if isinstance(raw, str):
                content = raw
            elif isinstance(raw, dict):
                # Common patterns: plain text, or { "parts": [...] } structures.
                content = raw.get("text") or " ".join(raw.get("parts", [])) or ""
            else:
                content = str(raw)
        else:
            # Fallback for dict-like choices
            content = (getattr(choice, "get", lambda k, d=None: d)("message") or {}).get("content", "") or ""

        content_lower = content.lower()
        has_keyword = any(k in content_lower for k in ["calendar", "meeting", "standup"])

        self.assertTrue(made_tool_call or has_keyword)

python3 -m unittest -v