Test code emitter

"""Generated tests for {server_name} MCP server."""

# Pytest style
import pytest
from mcp_eval import Expect
from mcp_eval.session import TestAgent

# Decorator style  
from mcp_eval import task, setup, teardown, Expect
from mcp_eval.session import TestAgent, TestSession

# Dataset style
from mcp_eval import Case, Dataset, test_session
from mcp_eval.evaluators import (
    ToolWasCalled,
    ResponseContains,
    LLMJudge,
    # ... other evaluators as needed
)

@pytest.mark.asyncio
async def test_{name}(mcp_agent: TestAgent):
    """{description}"""
    response = await mcp_agent.generate_str(
        {prompt!r}
    )
    
    # Tool assertions (deferred)
    await mcp_agent.session.assert_that(
        Expect.tools.was_called("tool_name"),
        name="tool_was_called"
    )
    
    # Content assertions (immediate)
    await mcp_agent.session.assert_that(
        Expect.content.contains("text"),
        response=response,
        name="has_expected_content"  
    )
    
    # Performance assertions (deferred)
    await mcp_agent.session.assert_that(
        Expect.performance.max_iterations(3),
        name="efficient_execution"
    )
    
    # Judge assertions (immediate)
    await mcp_agent.session.assert_that(
        Expect.judge.llm("Evaluation rubric", min_score=0.8),
        response=response,
        name="quality_check"
    )

@task({name!r})
async def test_{identifier}(agent: TestAgent, session: TestSession):
    """{description}"""
    response = await agent.generate_str(
        {prompt!r}
    )
    
    # All assertions through session
    await session.assert_that(
        Expect.tools.was_called("tool_name"),
        name="tool_check"
    )
    
    await session.assert_that(
        Expect.content.contains("expected"),
        response=response,
        name="content_check"
    )

dataset = Dataset(
    name="Generated tests for {server_name}",
    cases=[
        Case(
            name={name!r},
            inputs={prompt!r},
            expected_output={expected!r},  # Optional
            metadata={{
                "description": {description!r},
                "difficulty": "medium",
                "category": "functionality"
            }},
            evaluators=[
                ToolWasCalled("tool_name"),
                ResponseContains("text", case_sensitive=False),
                LLMJudge("Evaluation criteria", min_score=0.8)
            ]
        ),
        # More cases...
    ]
)

# tool_was_called
spec: {"kind": "tool_was_called", "tool_name": "fetch", "min_times": 2}
code: Expect.tools.was_called("fetch", min_times=2)

# tool_called_with  
spec: {"kind": "tool_called_with", "tool_name": "calc", "arguments": {"x": 1}}
code: Expect.tools.was_called_with("calc", arguments={"x": 1})

# response_contains
spec: {"kind": "response_contains", "text": "success", "case_sensitive": false}
code: Expect.content.contains("success", case_sensitive=False)

# not_contains
spec: {"kind": "not_contains", "text": "error"}  
code: Expect.content.not_contains("error")

# tool_output_matches
spec: {"kind": "tool_output_matches", "tool_name": "fetch", "expected_output": "data", "match_type": "contains"}
code: Expect.tools.output_matches(
    tool_name="fetch",
    expected_output="data", 
    match_type="contains"
)

# max_iterations
spec: {"kind": "max_iterations", "max_iterations": 3}
code: Expect.performance.max_iterations(3)

# response_time_under
spec: {"kind": "response_time_under", "ms": 5000}
code: Expect.performance.response_time_under(5000)

# llm_judge
spec: {"kind": "llm_judge", "rubric": "Quality check", "min_score": 0.8}
code: Expect.judge.llm("Quality check", min_score=0.8)

# tool_sequence
spec: {"kind": "tool_sequence", "sequence": ["auth", "fetch"], "allow_other_calls": true}
code: Expect.tools.sequence(["auth", "fetch"], allow_other_calls=True)

# Bad
def test_t1(): ...
def test_12345(): ...

# Good  
def test_basic_fetch(): ...
def test_error_recovery(): ...

async def test_fetch_multiple_urls(mcp_agent):
    """Test fetching multiple URLs in parallel.
    
    Verifies that the agent can efficiently fetch multiple
    URLs and aggregate results correctly.
    """

# Always name assertions for clarity
await session.assert_that(
    Expect.tools.was_called("fetch"),
    name="fetch_tool_used"  # Descriptive name
)

# Add context to complex assertions
try:
    await session.assert_that(assertion)
except AssertionError as e:
    raise AssertionError(f"Failed on scenario {name}: {e}")

# JSON null → Python None
spec: {"expected_output": null}
code: expected_output=None

# JSON true/false → Python True/False
spec: {"case_sensitive": false}
code: case_sensitive=False

# Properly escape quotes and special chars
prompt = 'Test with "quotes" and \\n newlines'
# or
prompt = "Test with \"quotes\" and \\n newlines"
# or  
prompt = """Test with "quotes" and
newlines"""

# Empty dict/list
arguments = {}  # Not {"": ""}
sequence = []   # Not [""]

"""Generated tests for {server_name} server.

Generated by mcp-eval on {timestamp}.
"""

# Imports (minimal, only what's used)
{imports}

# Setup/teardown if needed
@setup
def configure():
    """Test setup."""
    pass

# Test functions/classes
{test_functions}

# Optional: main block for direct execution
if __name__ == "__main__":
    # For decorator style
    import asyncio
    from mcp_eval.runner import run_tests
    asyncio.run(run_tests(__file__))
    
    # For pytest style
    # pytest.main([__file__, "-v"])

# Bad
def test-fetch-data(): ...  # Hyphen not allowed

# Good
def test_fetch_data(): ...  # Underscore

# Bad  
f"Test {undefined_var}"  # NameError

# Good
f"Test {{literal}}"  # Escaped braces
# or
"Test " + str(value)  # Concatenation

# Bad
Expect.tools.was_called(fetch)  # Missing quotes

# Good
Expect.tools.was_called("fetch")  # String literal