Buckets:
AnonymousSpottedToad/human_verified_bucket / codebase /python /luxman89_TradeArena /tests /test_battle_resolver.py
| """Tests for the battle resolver — scoring + draw conditions.""" | |
| from __future__ import annotations | |
| import uuid | |
| from datetime import UTC, datetime, timedelta | |
| import pytest | |
| from sqlalchemy import create_engine | |
| from sqlalchemy.orm import sessionmaker | |
| from sqlalchemy.pool import StaticPool | |
| from tradearena.core.battle_resolver import DRAW_THRESHOLD, resolve_battle | |
| from tradearena.db.database import Base, BattleORM, CreatorORM, SignalORM | |
| engine = create_engine( | |
| "sqlite://", | |
| connect_args={"check_same_thread": False}, | |
| poolclass=StaticPool, | |
| ) | |
| TestSession = sessionmaker(autocommit=False, autoflush=False, bind=engine) | |
| def reset_db(): | |
| Base.metadata.drop_all(bind=engine) | |
| Base.metadata.create_all(bind=engine) | |
| yield | |
| def db(): | |
| session = TestSession() | |
| try: | |
| yield session | |
| finally: | |
| session.close() | |
| def _make_creator(db, creator_id: str) -> CreatorORM: | |
| c = CreatorORM( | |
| id=creator_id, | |
| display_name=creator_id.title(), | |
| created_at=datetime.now(UTC) - timedelta(days=60), | |
| division="crypto", | |
| ) | |
| db.add(c) | |
| db.commit() | |
| return c | |
| def _make_signal( | |
| db, | |
| creator_id: str, | |
| outcome: str | None = "WIN", | |
| confidence: float = 0.7, | |
| days_ago: int = 3, | |
| ) -> SignalORM: | |
| sig_id = uuid.uuid4().hex | |
| reasoning = ( | |
| "This is a detailed technical analysis signal with RSI divergence and " | |
| "volume confirmation across multiple timeframes showing clear momentum " | |
| "shift above the key resistance breakout level." | |
| ) | |
| s = SignalORM( | |
| signal_id=sig_id, | |
| creator_id=creator_id, | |
| asset="BTC/USDT", | |
| action="BUY", | |
| confidence=confidence, | |
| reasoning=reasoning, | |
| supporting_data={"rsi": 55, "volume": 1000000}, | |
| commitment_hash=uuid.uuid4().hex + uuid.uuid4().hex[:32], | |
| committed_at=datetime.now(UTC) - timedelta(days=days_ago), | |
| outcome=outcome, | |
| outcome_price=50000.0 if outcome else None, | |
| outcome_at=datetime.now(UTC) - timedelta(days=days_ago - 1) if outcome else None, | |
| ) | |
| db.add(s) | |
| db.commit() | |
| return s | |
| def _make_battle( | |
| db, c1_id: str, c2_id: str, window_days: int = 7, battle_type: str = "MANUAL" | |
| ) -> BattleORM: | |
| b = BattleORM( | |
| battle_id=uuid.uuid4().hex, | |
| creator1_id=c1_id, | |
| creator2_id=c2_id, | |
| status="ACTIVE", | |
| window_days=window_days, | |
| created_at=datetime.now(UTC), | |
| battle_type=battle_type, | |
| ) | |
| db.add(b) | |
| db.commit() | |
| return b | |
| class TestResolveBattle: | |
| def test_resolves_with_clear_winner(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| # Alice: all wins | |
| for i in range(5): | |
| _make_signal(db, "alice", outcome="WIN", confidence=0.8, days_ago=i + 1) | |
| # Bob: all losses | |
| for i in range(5): | |
| _make_signal(db, "bob", outcome="LOSS", confidence=0.3, days_ago=i + 1) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is not None | |
| assert result.status == "RESOLVED" | |
| assert result.winner_id == "alice" | |
| assert result.creator1_score > result.creator2_score | |
| assert result.margin > 0 | |
| assert result.resolved_at is not None | |
| def test_returns_none_if_too_few_signals(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| _make_signal(db, "alice", outcome="WIN", days_ago=2) | |
| _make_signal(db, "alice", outcome="WIN", days_ago=3) | |
| # Bob only has 1 resolved signal | |
| _make_signal(db, "bob", outcome="WIN", days_ago=2) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is None | |
| def test_pending_signals_dont_count_for_minimum(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| _make_signal(db, "alice", outcome="WIN", days_ago=2) | |
| _make_signal(db, "alice", outcome="WIN", days_ago=3) | |
| # Bob has 2 signals but only 1 resolved | |
| _make_signal(db, "bob", outcome="WIN", days_ago=2) | |
| _make_signal(db, "bob", outcome=None, days_ago=3) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is None | |
| def test_draw_when_scores_very_close(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| # Same signals for both → identical scores → draw | |
| for cid in ("alice", "bob"): | |
| for i in range(5): | |
| _make_signal(db, cid, outcome="WIN", confidence=0.7, days_ago=i + 1) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is not None | |
| assert result.status == "RESOLVED" | |
| assert result.winner_id is None # draw | |
| assert result.margin < DRAW_THRESHOLD | |
| def test_details_contain_all_dimensions(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| for cid in ("alice", "bob"): | |
| for i in range(3): | |
| _make_signal(db, cid, outcome="WIN", days_ago=i + 1) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is not None | |
| expected_keys = { | |
| "win_rate", | |
| "risk_adjusted_return", | |
| "consistency", | |
| "confidence_calibration", | |
| "composite", | |
| } | |
| assert set(result.creator1_details.keys()) == expected_keys | |
| assert set(result.creator2_details.keys()) == expected_keys | |
| def test_window_excludes_old_signals(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| # Alice has wins but all outside the 7-day window | |
| for i in range(5): | |
| _make_signal(db, "alice", outcome="WIN", days_ago=10 + i) | |
| # Plus 2 recent losses | |
| _make_signal(db, "alice", outcome="LOSS", days_ago=1) | |
| _make_signal(db, "alice", outcome="LOSS", days_ago=2) | |
| # Bob has recent wins | |
| for i in range(5): | |
| _make_signal(db, "bob", outcome="WIN", days_ago=i + 1) | |
| battle = _make_battle(db, "alice", "bob", window_days=7) | |
| result = resolve_battle(battle, db) | |
| assert result is not None | |
| assert result.winner_id == "bob" | |
| def test_second_creator_wins(self, db): | |
| _make_creator(db, "alice") | |
| _make_creator(db, "bob") | |
| for i in range(3): | |
| _make_signal(db, "alice", outcome="LOSS", confidence=0.3, days_ago=i + 1) | |
| for i in range(3): | |
| _make_signal(db, "bob", outcome="WIN", confidence=0.9, days_ago=i + 1) | |
| battle = _make_battle(db, "alice", "bob") | |
| result = resolve_battle(battle, db) | |
| assert result is not None | |
| assert result.winner_id == "bob" | |
| assert result.creator2_score > result.creator1_score | |
Xet Storage Details
- Size:
- 7.24 kB
- Xet hash:
- b24cfe20a1eb82717adf488b13a5d2862ae428a7b5eeacdbcbc3368da0a073db
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.