feat: import 6 MCP services + common workspace

services/mcp-alpaca/tests/conftest.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from mcp_alpaca.client import AlpacaClient
+
+
+@pytest.fixture
+def mock_trading():
+    return MagicMock(name="alpaca_TradingClient")
+
+
+@pytest.fixture
+def mock_stock():
+    return MagicMock(name="alpaca_StockHistoricalDataClient")
+
+
+@pytest.fixture
+def mock_crypto():
+    return MagicMock(name="alpaca_CryptoHistoricalDataClient")
+
+
+@pytest.fixture
+def mock_option():
+    return MagicMock(name="alpaca_OptionHistoricalDataClient")
+
+
+@pytest.fixture
+def client(mock_trading, mock_stock, mock_crypto, mock_option):
+    return AlpacaClient(
+        api_key="test_key",
+        secret_key="test_secret",
+        paper=True,
+        trading=mock_trading,
+        stock_data=mock_stock,
+        crypto_data=mock_crypto,
+        option_data=mock_option,
+    )

services/mcp-alpaca/tests/test_client.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_init_paper_mode(client, mock_trading):
+    assert client.paper is True
+    assert client._trading is mock_trading
+
+
+@pytest.mark.asyncio
+async def test_get_account_calls_trading(client, mock_trading):
+    mock_trading.get_account.return_value = MagicMock(
+        model_dump=lambda: {"equity": 100000, "cash": 50000}
+    )
+    result = await client.get_account()
+    mock_trading.get_account.assert_called_once()
+    assert result["equity"] == 100000
+
+
+@pytest.mark.asyncio
+async def test_get_positions_returns_list(client, mock_trading):
+    pos_mock = MagicMock(model_dump=lambda: {"symbol": "AAPL", "qty": 10})
+    mock_trading.get_all_positions.return_value = [pos_mock]
+    result = await client.get_positions()
+    assert len(result) == 1
+    assert result[0]["symbol"] == "AAPL"
+
+
+@pytest.mark.asyncio
+async def test_place_market_order_stocks(client, mock_trading):
+    order_mock = MagicMock(model_dump=lambda: {"id": "o123", "symbol": "AAPL"})
+    mock_trading.submit_order.return_value = order_mock
+    result = await client.place_order(
+        symbol="AAPL", side="buy", qty=1, order_type="market", asset_class="stocks",
+    )
+    assert result["id"] == "o123"
+    assert mock_trading.submit_order.called
+
+
+@pytest.mark.asyncio
+async def test_place_limit_order_requires_price(client):
+    with pytest.raises(ValueError, match="limit_price"):
+        await client.place_order(
+            symbol="AAPL", side="buy", qty=1, order_type="limit",
+        )
+
+
+@pytest.mark.asyncio
+async def test_cancel_order(client, mock_trading):
+    mock_trading.cancel_order_by_id.return_value = None
+    result = await client.cancel_order("o1")
+    mock_trading.cancel_order_by_id.assert_called_once_with("o1")
+    assert result == {"order_id": "o1", "canceled": True}
+
+
+@pytest.mark.asyncio
+async def test_close_position_no_options(client, mock_trading):
+    order_mock = MagicMock(model_dump=lambda: {"id": "close-1"})
+    mock_trading.close_position.return_value = order_mock
+    result = await client.close_position("AAPL")
+    assert mock_trading.close_position.called
+    assert result["id"] == "close-1"
+
+
+@pytest.mark.asyncio
+async def test_get_clock(client, mock_trading):
+    clock_mock = MagicMock(model_dump=lambda: {"is_open": True, "next_close": "2026-04-21T20:00:00Z"})
+    mock_trading.get_clock.return_value = clock_mock
+    result = await client.get_clock()
+    assert result["is_open"] is True
+
+
+@pytest.mark.asyncio
+async def test_invalid_asset_class(client):
+    with pytest.raises(ValueError, match="invalid asset_class"):
+        await client.get_ticker("AAPL", asset_class="forex")

services/mcp-alpaca/tests/test_server_acl.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from fastapi.testclient import TestClient
+from option_mcp_common.auth import Principal, TokenStore
+
+from mcp_alpaca.server import create_app
+
+
+@pytest.fixture
+def token_store():
+    return TokenStore(
+        tokens={
+            "core-tok": Principal("core", {"core"}),
+            "obs-tok": Principal("observer", {"observer"}),
+        }
+    )
+
+
+@pytest.fixture
+def mock_client():
+    c = MagicMock()
+    c.get_account = AsyncMock(return_value={"equity": 100000})
+    c.get_positions = AsyncMock(return_value=[])
+    c.get_activities = AsyncMock(return_value=[])
+    c.get_assets = AsyncMock(return_value=[])
+    c.get_ticker = AsyncMock(return_value={"symbol": "AAPL"})
+    c.get_bars = AsyncMock(return_value={"bars": []})
+    c.get_snapshot = AsyncMock(return_value={})
+    c.get_option_chain = AsyncMock(return_value={"contracts": []})
+    c.get_open_orders = AsyncMock(return_value=[])
+    c.get_clock = AsyncMock(return_value={"is_open": True})
+    c.get_calendar = AsyncMock(return_value=[])
+    c.place_order = AsyncMock(return_value={"id": "o1"})
+    c.amend_order = AsyncMock(return_value={"id": "o1"})
+    c.cancel_order = AsyncMock(return_value={"canceled": True})
+    c.cancel_all_orders = AsyncMock(return_value=[])
+    c.close_position = AsyncMock(return_value={"id": "close1"})
+    c.close_all_positions = AsyncMock(return_value=[])
+    return c
+
+
+@pytest.fixture
+def http(mock_client, token_store):
+    app = create_app(client=mock_client, token_store=token_store)
+    return TestClient(app)
+
+
+CORE = {"Authorization": "Bearer core-tok"}
+OBS = {"Authorization": "Bearer obs-tok"}
+
+READ_ENDPOINTS = [
+    ("/tools/get_account", {}),
+    ("/tools/get_positions", {}),
+    ("/tools/get_activities", {}),
+    ("/tools/get_assets", {}),
+    ("/tools/get_ticker", {"symbol": "AAPL"}),
+    ("/tools/get_bars", {"symbol": "AAPL"}),
+    ("/tools/get_snapshot", {"symbol": "AAPL"}),
+    ("/tools/get_option_chain", {"underlying": "AAPL"}),
+    ("/tools/get_open_orders", {}),
+    ("/tools/get_clock", {}),
+    ("/tools/get_calendar", {}),
+]
+
+WRITE_ENDPOINTS = [
+    ("/tools/place_order", {"symbol": "AAPL", "side": "buy", "qty": 1}),
+    ("/tools/amend_order", {"order_id": "o1", "qty": 2}),
+    ("/tools/cancel_order", {"order_id": "o1"}),
+    ("/tools/cancel_all_orders", {}),
+    ("/tools/close_position", {"symbol": "AAPL"}),
+    ("/tools/close_all_positions", {}),
+]
+
+
+@pytest.mark.parametrize("path,payload", READ_ENDPOINTS)
+def test_read_core_ok(http, path, payload):
+    r = http.post(path, json=payload, headers=CORE)
+    assert r.status_code == 200, (path, r.text)
+
+
+@pytest.mark.parametrize("path,payload", READ_ENDPOINTS)
+def test_read_observer_ok(http, path, payload):
+    r = http.post(path, json=payload, headers=OBS)
+    assert r.status_code == 200, (path, r.text)
+
+
+@pytest.mark.parametrize("path,payload", READ_ENDPOINTS)
+def test_read_no_auth_401(http, path, payload):
+    r = http.post(path, json=payload)
+    assert r.status_code == 401, (path, r.text)
+
+
+@pytest.mark.parametrize("path,payload", WRITE_ENDPOINTS)
+def test_write_core_ok(http, path, payload):
+    r = http.post(path, json=payload, headers=CORE)
+    assert r.status_code == 200, (path, r.text)
+
+
+@pytest.mark.parametrize("path,payload", WRITE_ENDPOINTS)
+def test_write_observer_403(http, path, payload):
+    r = http.post(path, json=payload, headers=OBS)
+    assert r.status_code == 403, (path, r.text)
+
+
+@pytest.mark.parametrize("path,payload", WRITE_ENDPOINTS)
+def test_write_no_auth_401(http, path, payload):
+    r = http.post(path, json=payload)
+    assert r.status_code == 401, (path, r.text)