We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jkoelker/schwab-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
"""TDD tests for new conftest fixtures.
These tests verify the behavior of three new fixtures that will be added to conftest.py:
- fake_call_factory: Creates a fake call function with optional return value
- order_response_factory: Creates a mock HTTP response for order placement
- place_order_client_factory: Creates a client that captures place_order() calls
Tests are written in RED phase (expected to fail until fixtures are implemented).
"""
from __future__ import annotations
import asyncio
from typing import Any
class TestFakeCallFactory:
"""Tests for fake_call_factory fixture."""
def test_fake_call_factory_returns_tuple(self, fake_call_factory):
"""Verify fake_call_factory returns (captured, fake_call) tuple."""
result = fake_call_factory()
assert isinstance(result, tuple)
assert len(result) == 2
def test_fake_call_factory_captures_function_reference(self, fake_call_factory):
"""Verify fake_call_factory captures the function being called."""
captured, fake_call = fake_call_factory()
async def dummy_func(x: int, y: int) -> int:
return x + y
asyncio.run(fake_call(dummy_func, 1, 2))
assert captured["func"] == dummy_func
def test_fake_call_factory_captures_positional_args(self, fake_call_factory):
"""Verify fake_call_factory captures positional arguments."""
captured, fake_call = fake_call_factory()
async def dummy_func(x: int, y: int) -> int:
return x + y
asyncio.run(fake_call(dummy_func, 42, 99))
assert captured["args"] == (42, 99)
def test_fake_call_factory_captures_keyword_args(self, fake_call_factory):
"""Verify fake_call_factory captures keyword arguments."""
captured, fake_call = fake_call_factory()
async def dummy_func(x: int, y: int) -> int:
return x + y
asyncio.run(fake_call(dummy_func, 1, 2, z=3, w=4))
assert captured["kwargs"] == {"z": 3, "w": 4}
def test_fake_call_factory_returns_default_value(self, fake_call_factory):
"""Verify fake_call_factory returns 'ok' by default."""
captured, fake_call = fake_call_factory()
async def dummy_func() -> None:
pass
result = asyncio.run(fake_call(dummy_func))
assert result == "ok"
def test_fake_call_factory_accepts_custom_return_value(self, fake_call_factory):
"""Verify fake_call_factory accepts optional return_value parameter."""
custom_return = {"status": "success", "data": [1, 2, 3]}
captured, fake_call = fake_call_factory(return_value=custom_return)
async def dummy_func() -> None:
pass
result = asyncio.run(fake_call(dummy_func))
assert result == custom_return
def test_fake_call_factory_with_mixed_args_and_kwargs(self, fake_call_factory):
"""Verify fake_call_factory handles mixed args and kwargs correctly."""
captured, fake_call = fake_call_factory()
async def dummy_func(a: int, b: int, c: int = 0) -> int:
return a + b + c
asyncio.run(fake_call(dummy_func, 10, 20, c=30, d=40))
assert captured["args"] == (10, 20)
assert captured["kwargs"] == {"c": 30, "d": 40}
class TestOrderResponseFactory:
"""Tests for order_response_factory fixture."""
def test_order_response_factory_creates_response(self, order_response_factory):
"""Verify order_response_factory creates a response object."""
response = order_response_factory()
assert response is not None
def test_order_response_factory_sets_status_code_201(self, order_response_factory):
"""Verify order_response_factory sets status_code to 201."""
response = order_response_factory()
assert response.status_code == 201
def test_order_response_factory_sets_location_header(self, order_response_factory):
"""Verify order_response_factory sets Location header with order ID."""
account_hash = "test_account_hash"
order_id = 987654321
response = order_response_factory(account_hash=account_hash, order_id=order_id)
expected_location = f"https://api.schwabapi.com/trader/v1/accounts/{account_hash}/orders/{order_id}"
assert response.headers["Location"] == expected_location
def test_order_response_factory_sets_url(self, order_response_factory):
"""Verify order_response_factory sets url to orders endpoint."""
account_hash = "my_account"
response = order_response_factory(account_hash=account_hash)
expected_url = (
f"https://api.schwabapi.com/trader/v1/accounts/{account_hash}/orders"
)
assert response.url == expected_url
def test_order_response_factory_has_raise_for_status(self, order_response_factory):
"""Verify order_response_factory response has raise_for_status method."""
response = order_response_factory()
assert hasattr(response, "raise_for_status")
assert callable(response.raise_for_status)
def test_order_response_factory_raise_for_status_succeeds(
self, order_response_factory
):
"""Verify raise_for_status() doesn't raise for 201 status."""
response = order_response_factory()
# Should not raise
response.raise_for_status()
def test_order_response_factory_has_text_and_content(self, order_response_factory):
"""Verify order_response_factory response has text and content attributes."""
response = order_response_factory()
assert hasattr(response, "text")
assert hasattr(response, "content")
class TestPlaceOrderClientFactory:
"""Tests for place_order_client_factory fixture."""
def test_place_order_client_factory_creates_client(
self, place_order_client_factory
):
"""Verify place_order_client_factory creates a client object."""
client = place_order_client_factory()
assert client is not None
def test_place_order_client_factory_client_has_place_order_method(
self, place_order_client_factory
):
"""Verify client has place_order method."""
client = place_order_client_factory()
assert hasattr(client, "place_order")
assert callable(client.place_order)
def test_place_order_client_factory_captures_place_order_call(
self, place_order_client_factory
):
"""Verify client captures place_order() calls."""
client = place_order_client_factory()
async def run_test() -> None:
await client.place_order("account123", {"symbol": "AAPL", "quantity": 10})
asyncio.run(run_test())
assert client.captured is not None
assert "args" in client.captured
assert "kwargs" in client.captured
def test_place_order_client_factory_captures_positional_args(
self, place_order_client_factory
):
"""Verify client captures positional arguments to place_order()."""
client = place_order_client_factory()
async def run_test() -> None:
await client.place_order("account123", {"symbol": "AAPL"})
asyncio.run(run_test())
assert client.captured["args"] == ("account123", {"symbol": "AAPL"})
def test_place_order_client_factory_captures_keyword_args(
self, place_order_client_factory
):
"""Verify client captures keyword arguments to place_order()."""
client = place_order_client_factory()
async def run_test() -> None:
await client.place_order(
"account123", {"symbol": "AAPL"}, session="EXTENDED", duration="GTC"
)
asyncio.run(run_test())
assert client.captured["kwargs"] == {"session": "EXTENDED", "duration": "GTC"}
def test_place_order_client_factory_returns_response(
self, place_order_client_factory
):
"""Verify client.place_order() returns a response object."""
client = place_order_client_factory()
async def run_test() -> Any:
return await client.place_order("account123", {"symbol": "AAPL"})
response = asyncio.run(run_test())
assert response is not None
assert hasattr(response, "status_code")
assert response.status_code == 201
def test_place_order_client_factory_response_has_location_header(
self, place_order_client_factory
):
"""Verify client.place_order() response has Location header."""
client = place_order_client_factory()
async def run_test() -> Any:
return await client.place_order("account123", {"symbol": "AAPL"})
response = asyncio.run(run_test())
assert "Location" in response.headers
assert "orders" in response.headers["Location"]