6fec9963fb
Some checks failed
ci/woodpecker/push/woodpecker Pipeline was canceled
Entries, deferrals and rejections posted to #trading-bot, but exits booked by the reconcile loop (bracket stop/take-profit legs that fill at Alpaca) were silent — the two Jun 9 stop-outs produced no message. Viktor asked for a Slack message on each position execution. - move SlackNotifier to shared/ (now used by trade-executor AND api-gateway) - add notify_close (ticker/qty/price/realized P&L/reason, win-loss emoji) - reconcile loop notifies on each booked close, fail-soft; api-gateway config gains slack fields (channel defaults to trading-bot since the env carries only the bot token; chat:write.public covers posting) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
243 lines
9.7 KiB
Python
243 lines
9.7 KiB
Python
"""Tests for the shared SlackNotifier (trade-executor + reconcile loop)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from datetime import datetime, timezone
|
|
from unittest.mock import AsyncMock, patch
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
from shared.slack_notifier import SlackNotifier
|
|
from shared.constants.kevin import KEVIN_STRATEGY_UUID
|
|
from shared.schemas.trading import (
|
|
OrderResult,
|
|
OrderSide,
|
|
OrderStatus,
|
|
SignalDirection,
|
|
TradeSignal,
|
|
)
|
|
|
|
|
|
def _signal(strategy_id=None, target_dollars=None) -> TradeSignal:
|
|
return TradeSignal(
|
|
ticker="NVDA",
|
|
direction=SignalDirection.LONG,
|
|
strength=0.85,
|
|
strategy_sources=["meet_kevin:buy:0.85"],
|
|
timestamp=datetime.now(timezone.utc),
|
|
strategy_id=strategy_id,
|
|
target_dollars=target_dollars,
|
|
)
|
|
|
|
|
|
def _filled_order(ticker="NVDA", qty=10, price=217.50) -> OrderResult:
|
|
return OrderResult(
|
|
order_id=str(uuid4()),
|
|
ticker=ticker,
|
|
side=OrderSide.BUY,
|
|
qty=qty,
|
|
filled_price=price,
|
|
status=OrderStatus.FILLED,
|
|
timestamp=datetime.now(timezone.utc),
|
|
)
|
|
|
|
|
|
class TestSlackNotifierNoWebhook:
|
|
"""Empty webhook_url -> notifier is a no-op (returns without raising)."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_notify_trade_noop(self):
|
|
notifier = SlackNotifier(webhook_url="")
|
|
# should not raise even with no mock
|
|
await notifier.notify_trade(_signal(), _filled_order())
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_notify_rejection_noop(self):
|
|
notifier = SlackNotifier(webhook_url="")
|
|
await notifier.notify_rejection(_signal(), "outside_market_hours")
|
|
|
|
|
|
class TestSlackNotifierTradePost:
|
|
@pytest.mark.asyncio
|
|
async def test_trade_post_calls_webhook(self):
|
|
notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_post = AsyncMock(return_value=AsyncMock(status_code=200))
|
|
mock_client.post = mock_post
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_trade(
|
|
_signal(strategy_id=KEVIN_STRATEGY_UUID),
|
|
_filled_order(qty=10, price=217.50),
|
|
)
|
|
mock_post.assert_called_once()
|
|
url, kwargs = mock_post.call_args.args[0], mock_post.call_args.kwargs
|
|
assert url == "https://hooks.slack.test/abc"
|
|
payload = kwargs["json"]
|
|
assert "NVDA" in payload["text"]
|
|
assert "10" in payload["text"]
|
|
assert "217.50" in payload["text"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_trade_post_strategy_tag_when_kevin(self):
|
|
notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=AsyncMock(status_code=200))
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_trade(
|
|
_signal(strategy_id=KEVIN_STRATEGY_UUID),
|
|
_filled_order(),
|
|
)
|
|
payload = mock_client.post.call_args.kwargs["json"]
|
|
assert "Meet Kevin" in payload["text"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_trade_post_swallows_http_errors(self):
|
|
"""A failed Slack post must NOT bubble up — the trade already
|
|
happened; we shouldn't crash the consumer loop because Slack is
|
|
having a bad day."""
|
|
notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(side_effect=Exception("network down"))
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
# should NOT raise
|
|
await notifier.notify_trade(_signal(), _filled_order())
|
|
|
|
|
|
class TestSlackNotifierBotToken:
|
|
@pytest.mark.asyncio
|
|
async def test_bot_token_calls_chat_postmessage(self):
|
|
notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
|
|
assert notifier.uses_bot_token
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_resp = AsyncMock()
|
|
mock_resp.json = lambda: {"ok": True, "ts": "1.2"}
|
|
mock_client.post = AsyncMock(return_value=mock_resp)
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_trade(_signal(), _filled_order())
|
|
url = mock_client.post.call_args.args[0]
|
|
assert url == "https://slack.com/api/chat.postMessage"
|
|
kwargs = mock_client.post.call_args.kwargs
|
|
assert kwargs["headers"]["Authorization"] == "Bearer xoxb-test"
|
|
body = kwargs["json"]
|
|
assert body["channel"] == "trading-bot"
|
|
assert "NVDA" in body["text"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_bot_token_swallows_channel_not_found(self):
|
|
"""When the user hasn't created #trading-bot yet, the API returns
|
|
ok=false / error=channel_not_found. We log and continue."""
|
|
notifier = SlackNotifier(bot_token="xoxb-test", channel="nonexistent")
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_resp = AsyncMock()
|
|
mock_resp.json = lambda: {"ok": False, "error": "channel_not_found"}
|
|
mock_client.post = AsyncMock(return_value=mock_resp)
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
# should not raise
|
|
await notifier.notify_trade(_signal(), _filled_order())
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_bot_token_wins_when_both_set(self):
|
|
notifier = SlackNotifier(
|
|
webhook_url="https://hooks.slack.test/abc",
|
|
bot_token="xoxb-test",
|
|
channel="trading-bot",
|
|
)
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=AsyncMock(json=lambda: {"ok": True}))
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_trade(_signal(), _filled_order())
|
|
assert mock_client.post.call_args.args[0] == "https://slack.com/api/chat.postMessage"
|
|
|
|
|
|
class TestSlackNotifierRejectionPost:
|
|
@pytest.mark.asyncio
|
|
async def test_rejection_post_calls_webhook(self):
|
|
notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock(return_value=AsyncMock(status_code=200))
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_rejection(
|
|
_signal(strategy_id=KEVIN_STRATEGY_UUID),
|
|
reason="kevin_daily_trade_cap",
|
|
)
|
|
payload = mock_client.post.call_args.kwargs["json"]
|
|
assert "REJECTED" in payload["text"]
|
|
assert "kevin_daily_trade_cap" in payload["text"]
|
|
assert "NVDA" in payload["text"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rejection_post_skips_noise(self):
|
|
"""outside_market_hours fires every minute when the bot tries to
|
|
trade after-hours — we don't want a Slack barrage. The notifier
|
|
skips it."""
|
|
notifier = SlackNotifier(
|
|
webhook_url="https://hooks.slack.test/abc",
|
|
quiet_rejections={"outside_market_hours"},
|
|
)
|
|
with patch("httpx.AsyncClient") as mock_client_cls:
|
|
mock_client = AsyncMock()
|
|
mock_client.post = AsyncMock()
|
|
mock_client_cls.return_value.__aenter__.return_value = mock_client
|
|
await notifier.notify_rejection(_signal(), "outside_market_hours")
|
|
mock_client.post.assert_not_called()
|
|
|
|
|
|
class TestSlackNotifierClosePost:
|
|
"""notify_close — reconcile-booked exits (bracket legs that fill at
|
|
Alpaca without passing through the executor) must reach Slack."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_posts_loss_with_pnl(self):
|
|
notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
|
|
with patch.object(notifier, "_post", new=AsyncMock()) as post:
|
|
await notifier.notify_close(
|
|
ticker="MRVL",
|
|
qty=9,
|
|
price=263.61,
|
|
pnl=-243.87,
|
|
strategy_id=KEVIN_STRATEGY_UUID,
|
|
reason="bracket leg filled",
|
|
)
|
|
text = post.call_args[0][0]
|
|
assert "Meet Kevin" in text
|
|
assert "MRVL" in text
|
|
assert "263.61" in text
|
|
assert "-$243.87" in text
|
|
assert "bracket leg filled" in text
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_posts_win_with_positive_pnl(self):
|
|
notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
|
|
with patch.object(notifier, "_post", new=AsyncMock()) as post:
|
|
await notifier.notify_close(
|
|
ticker="TSM",
|
|
qty=6,
|
|
price=440.0,
|
|
pnl=83.06,
|
|
strategy_id=KEVIN_STRATEGY_UUID,
|
|
reason="take-profit filled",
|
|
)
|
|
text = post.call_args[0][0]
|
|
assert "+$83.06" in text
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_noop_when_disabled(self):
|
|
notifier = SlackNotifier()
|
|
with patch.object(notifier, "_post", new=AsyncMock()) as post:
|
|
await notifier.notify_close(
|
|
ticker="TSM",
|
|
qty=6,
|
|
price=440.0,
|
|
pnl=1.0,
|
|
strategy_id=None,
|
|
reason="x",
|
|
)
|
|
post.assert_not_called()
|