Compare commits
1 Commits
fix/issue-
...
d018e87b35
| Author | SHA1 | Date | |
|---|---|---|---|
|
d018e87b35 |
@@ -45,65 +45,49 @@ def fetch_page(q, page=1, max_retries=MAX_RETRIES, initial_delay=INITIAL_RETRY_D
|
||||
|
||||
delay = initial_delay
|
||||
for attempt in range(max_retries):
|
||||
if attempt > 0:
|
||||
time.sleep(delay)
|
||||
r = subprocess.run(
|
||||
["curl", "-s", url, "--max-time", "10", "-H", "User-Agent: curl/7.88.1"],
|
||||
capture_output=True
|
||||
)
|
||||
|
||||
if r.returncode == 0 and len(r.stdout) > 0:
|
||||
try:
|
||||
req = Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||||
with urlopen(req, timeout=10) as r:
|
||||
return json.loads(r.read())
|
||||
except Exception:
|
||||
return json.loads(r.stdout.decode('utf-8'))
|
||||
except json.JSONDecodeError:
|
||||
if attempt < max_retries - 1:
|
||||
delay *= 2 # Exponential backoff
|
||||
continue
|
||||
return None
|
||||
else:
|
||||
# Rate limit or other error - exponential backoff
|
||||
if attempt < max_retries - 1:
|
||||
delay *= 2
|
||||
continue
|
||||
return None
|
||||
return None
|
||||
|
||||
def fetch_all_pages(q, matches_max=None, non_matches_max=None):
|
||||
def fetch_all_pages(q, max_pages=100):
|
||||
"""
|
||||
Fetch pages until pagination ends, or until quotas are satisfied.
|
||||
|
||||
Args:
|
||||
q: search query
|
||||
matches_max: stop early once we have this many match events (None = no limit)
|
||||
non_matches_max: stop early once we have this many non-match events (None = no limit)
|
||||
|
||||
Returns:
|
||||
{"events": [...], "total_raw": N, "partial": bool}
|
||||
Fetch ALL pages until pagination ends.
|
||||
max_pages is a safety cap to prevent infinite loops.
|
||||
"""
|
||||
all_events = []
|
||||
total_raw = 0
|
||||
match_count = 0
|
||||
non_match_count = 0
|
||||
page = 0
|
||||
while True:
|
||||
page += 1
|
||||
time.sleep(0.2)
|
||||
for page in range(1, max_pages + 1):
|
||||
time.sleep(0.2) # small delay between pages (API rate limit is generous)
|
||||
data = fetch_page(q, page)
|
||||
if data is None:
|
||||
break
|
||||
events = data.get("events", [])
|
||||
total_raw = data.get("pagination", {}).get("totalResults", 0)
|
||||
all_events.extend(events)
|
||||
|
||||
# Count matches/non-matches in this page
|
||||
for e in events:
|
||||
if is_match_market(e):
|
||||
match_count += 1
|
||||
else:
|
||||
non_match_count += 1
|
||||
|
||||
# Stop if we got what we wanted (only when caps are set)
|
||||
if matches_max is not None and non_matches_max is not None:
|
||||
if match_count >= matches_max and non_match_count >= non_matches_max:
|
||||
break
|
||||
|
||||
# Stop when we get 0 events (no more pages)
|
||||
# Stop when we get 0 events (no more pages),
|
||||
# OR when we've fetched >= total results
|
||||
if len(events) == 0:
|
||||
break
|
||||
# Stop when we've fetched all known results
|
||||
if len(all_events) >= total_raw:
|
||||
break
|
||||
|
||||
partial = (total_raw > 0 and len(all_events) < total_raw)
|
||||
return {"events": all_events, "total_raw": total_raw, "partial": partial}
|
||||
|
||||
@@ -337,39 +321,18 @@ def sort_events(events):
|
||||
# BROWSE
|
||||
# ============================================================
|
||||
|
||||
def browse_events(q, matches_max=10, non_matches_max=10, tradeable_only=True, sort_by=None):
|
||||
"""
|
||||
Browse Polymarket events.
|
||||
|
||||
Args:
|
||||
q: search query
|
||||
matches_max: max number of match markets to return
|
||||
non_matches_max: max number of non-match markets to return
|
||||
tradeable_only: filter to tradeable events only
|
||||
sort_by: None (fast, API order) or "volume" (full fetch, sort by volume desc)
|
||||
"""
|
||||
# Pass quotas to fetch_all_pages for early-exit optimization.
|
||||
# Only use early-exit when sort_by is None (no client-side sort needed).
|
||||
use_early_exit = (sort_by is None)
|
||||
fetch_matches_max = matches_max if use_early_exit else None
|
||||
fetch_non_matches_max = non_matches_max if use_early_exit else None
|
||||
|
||||
result = fetch_all_pages(q, matches_max=fetch_matches_max, non_matches_max=fetch_non_matches_max)
|
||||
def browse_events(q, matches_max=10, non_matches_max=10, tradeable_only=True):
|
||||
result = fetch_all_pages(q)
|
||||
events = result["events"]
|
||||
match_events, non_match_events = filter_events(events, tradeable_only)
|
||||
|
||||
# Sort if requested; otherwise preserve API order
|
||||
if sort_by == "volume":
|
||||
match_events = sort_events(match_events)
|
||||
non_match_events = sort_events(non_match_events)
|
||||
|
||||
sorted_match = sort_events(match_events)
|
||||
return {
|
||||
"query": q,
|
||||
"total_raw": result["total_raw"],
|
||||
"total_fetched": len(events),
|
||||
"total_match": len(match_events),
|
||||
"total_non_match": len(non_match_events),
|
||||
"match_events": match_events[:matches_max],
|
||||
"match_events": sorted_match[:matches_max],
|
||||
"non_match_events": non_match_events[:non_matches_max],
|
||||
"partial": result.get("partial", False),
|
||||
}
|
||||
|
||||
@@ -772,438 +772,5 @@ class TestSendChunked(unittest.TestCase):
|
||||
self.assertTrue(cont_found, f"Expected at least one '(cont.)' message. Got {len(sent_texts)} messages.")
|
||||
|
||||
|
||||
class TestIsMatchMarket(unittest.TestCase):
|
||||
"""Tests for is_match_market() classification."""
|
||||
|
||||
def test_match_when_series_and_gameid(self):
|
||||
"""seriesSlug + gameId present -> match market."""
|
||||
from browse import is_match_market
|
||||
e = {"seriesSlug": "esl-pro-league", "gameId": "12345", "title": "Tournament Winner"}
|
||||
self.assertTrue(is_match_market(e))
|
||||
|
||||
def test_match_when_vs_in_title(self):
|
||||
"""' vs ' in title -> match market."""
|
||||
from browse import is_match_market
|
||||
e = {"title": "Team A vs Team B - Final"}
|
||||
self.assertTrue(is_match_market(e))
|
||||
|
||||
def test_non_match_without_series_and_gameid(self):
|
||||
"""No seriesSlug/gameId and no ' vs ' -> non-match."""
|
||||
from browse import is_match_market
|
||||
e = {"title": "Will Team A win the tournament?"}
|
||||
self.assertFalse(is_match_market(e))
|
||||
|
||||
def test_non_match_seriesSlug_only(self):
|
||||
"""Only seriesSlug (no gameId) -> non-match."""
|
||||
from browse import is_match_market
|
||||
e = {"seriesSlug": "esl-pro-league", "title": "Tournament Winner"}
|
||||
self.assertFalse(is_match_market(e))
|
||||
|
||||
def test_non_match_gameid_only(self):
|
||||
"""Only gameId (no seriesSlug) -> non-match."""
|
||||
from browse import is_match_market
|
||||
e = {"gameId": "12345", "title": "Tournament Winner"}
|
||||
self.assertFalse(is_match_market(e))
|
||||
|
||||
|
||||
class TestGetMlMarket(unittest.TestCase):
|
||||
"""Tests for get_ml_market() and get_ml_volume()."""
|
||||
|
||||
def test_get_ml_market_finds_moneyline(self):
|
||||
"""Finds and returns the moneyline market."""
|
||||
from browse import get_ml_market
|
||||
e = {
|
||||
"markets": [
|
||||
{"sportsMarketType": "spread", "volume": "1000"},
|
||||
{"sportsMarketType": "moneyline", "volume": "50000"},
|
||||
{"sportsMarketType": "total", "volume": "2000"},
|
||||
]
|
||||
}
|
||||
ml = get_ml_market(e)
|
||||
self.assertEqual(ml["sportsMarketType"], "moneyline")
|
||||
self.assertEqual(ml["volume"], "50000")
|
||||
|
||||
def test_get_ml_market_returns_none_when_missing(self):
|
||||
"""Returns None when no moneyline market exists."""
|
||||
from browse import get_ml_market
|
||||
e = {"markets": [{"sportsMarketType": "spread", "volume": "1000"}]}
|
||||
self.assertIsNone(get_ml_market(e))
|
||||
|
||||
def test_get_ml_market_returns_none_when_no_markets(self):
|
||||
"""Returns None when event has no markets."""
|
||||
from browse import get_ml_market
|
||||
e = {}
|
||||
self.assertIsNone(get_ml_market(e))
|
||||
|
||||
def test_get_ml_volume_with_ml(self):
|
||||
"""Returns float volume from moneyline market."""
|
||||
from browse import get_ml_volume
|
||||
e = {
|
||||
"markets": [
|
||||
{"sportsMarketType": "moneyline", "volume": "123456"}
|
||||
]
|
||||
}
|
||||
self.assertEqual(get_ml_volume(e), 123456.0)
|
||||
|
||||
def test_get_ml_volume_no_ml(self):
|
||||
"""Returns 0.0 when no moneyline market."""
|
||||
from browse import get_ml_volume
|
||||
e = {"markets": []}
|
||||
self.assertEqual(get_ml_volume(e), 0.0)
|
||||
|
||||
|
||||
class TestFilterEvents(unittest.TestCase):
|
||||
"""Tests for filter_events() and sort_events()."""
|
||||
|
||||
def _make_match(self, match_id, tradeable=True, vol="50000"):
|
||||
return {
|
||||
"id": str(match_id),
|
||||
"title": f"Team A vs Team B - Match {match_id}",
|
||||
"seriesSlug": "test-league",
|
||||
"gameId": str(match_id),
|
||||
"markets": [{
|
||||
"sportsMarketType": "moneyline",
|
||||
"volume": vol,
|
||||
"bestBid": "0.50",
|
||||
"bestAsk": "0.52",
|
||||
"acceptingOrders": tradeable,
|
||||
"closed": False,
|
||||
}],
|
||||
}
|
||||
|
||||
def _make_non_match(self, event_id, tradeable=True):
|
||||
return {
|
||||
"id": f"nm{event_id}",
|
||||
"title": f"Will event {event_id} happen?",
|
||||
"markets": [{
|
||||
"sportsMarketType": "moneyline",
|
||||
"volume": "10000",
|
||||
"bestBid": "0.50",
|
||||
"bestAsk": "0.52",
|
||||
"acceptingOrders": tradeable,
|
||||
"closed": False,
|
||||
}],
|
||||
}
|
||||
|
||||
def test_filter_events_splits_match_and_non_match(self):
|
||||
"""Correctly splits events into match and non-match buckets."""
|
||||
from browse import filter_events
|
||||
events = [
|
||||
self._make_match(1),
|
||||
self._make_non_match(1),
|
||||
self._make_match(2),
|
||||
self._make_non_match(2),
|
||||
]
|
||||
matches, non_matches = filter_events(events, tradeable_only=False)
|
||||
self.assertEqual(len(matches), 2)
|
||||
self.assertEqual(len(non_matches), 2)
|
||||
self.assertEqual(matches[0]["id"], "1")
|
||||
self.assertEqual(non_matches[0]["id"], "nm1")
|
||||
|
||||
def test_filter_events_tradeable_only(self):
|
||||
"""tradeable_only=True filters out non-tradeable events."""
|
||||
from browse import filter_events
|
||||
events = [
|
||||
self._make_match(1, tradeable=True),
|
||||
self._make_match(2, tradeable=False),
|
||||
self._make_non_match(1),
|
||||
]
|
||||
matches, non_matches = filter_events(events, tradeable_only=True)
|
||||
self.assertEqual(len(matches), 1)
|
||||
self.assertEqual(matches[0]["id"], "1")
|
||||
self.assertEqual(len(non_matches), 1) # non-match with acceptingOrders=True passes
|
||||
|
||||
def test_filter_events_tradeable_only_false(self):
|
||||
"""tradeable_only=False keeps all events."""
|
||||
from browse import filter_events
|
||||
events = [
|
||||
self._make_match(1, tradeable=True),
|
||||
self._make_match(2, tradeable=False),
|
||||
self._make_non_match(1, tradeable=True),
|
||||
self._make_non_match(2, tradeable=False),
|
||||
]
|
||||
matches, non_matches = filter_events(events, tradeable_only=False)
|
||||
self.assertEqual(len(matches), 2)
|
||||
self.assertEqual(len(non_matches), 2)
|
||||
|
||||
def test_sort_events_by_volume_desc(self):
|
||||
"""sort_events returns events sorted by volume descending."""
|
||||
from browse import sort_events
|
||||
events = [
|
||||
self._make_match(1, vol="10000"),
|
||||
self._make_match(2, vol="50000"),
|
||||
self._make_match(3, vol="30000"),
|
||||
]
|
||||
sorted_evts = sort_events(events)
|
||||
self.assertEqual(sorted_evts[0]["id"], "2") # vol=50000
|
||||
self.assertEqual(sorted_evts[1]["id"], "3") # vol=30000
|
||||
self.assertEqual(sorted_evts[2]["id"], "1") # vol=10000
|
||||
|
||||
def test_sort_events_empty_list(self):
|
||||
"""sort_events handles empty list gracefully."""
|
||||
from browse import sort_events
|
||||
result = sort_events([])
|
||||
self.assertEqual(result, [])
|
||||
|
||||
|
||||
class TestFetchAllPages(unittest.TestCase):
|
||||
"""Tests for fetch_all_pages() early-exit logic."""
|
||||
|
||||
@patch('browse.fetch_page')
|
||||
@patch('browse.time.sleep')
|
||||
def test_early_exit_stops_when_both_quotas_met(self, mock_sleep, mock_fetch_page):
|
||||
"""Stops fetching once both match and non-match quotas are satisfied."""
|
||||
from browse import fetch_all_pages
|
||||
|
||||
# Page 1: 2 matches, 2 non-matches (neither quota met)
|
||||
page1 = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match 1", "seriesSlug": "x", "gameId": "1", "markets": []},
|
||||
{"id": "m2", "title": "Match 2", "seriesSlug": "x", "gameId": "2", "markets": []},
|
||||
{"id": "n1", "title": "Non-match 1", "markets": []},
|
||||
{"id": "n2", "title": "Non-match 2", "markets": []},
|
||||
],
|
||||
"pagination": {"totalResults": 10, "hasMore": True}
|
||||
}
|
||||
# Page 2: 1 match, 1 non-match (both quotas met: 3 matches >= 3, 3 non-matches >= 3)
|
||||
page2 = {
|
||||
"events": [
|
||||
{"id": "m3", "title": "Match 3", "seriesSlug": "x", "gameId": "3", "markets": []},
|
||||
{"id": "n3", "title": "Non-match 3", "markets": []},
|
||||
{"id": "m4", "title": "Match 4", "seriesSlug": "x", "gameId": "4", "markets": []},
|
||||
{"id": "n4", "title": "Non-match 4", "markets": []},
|
||||
],
|
||||
"pagination": {"totalResults": 10, "hasMore": True}
|
||||
}
|
||||
|
||||
mock_fetch_page.side_effect = [page1, page2] # should NOT reach page 2
|
||||
|
||||
result = fetch_all_pages("test", matches_max=3, non_matches_max=3)
|
||||
|
||||
# Should stop after page 1 (quota met: 2 matches < 3? NO wait)
|
||||
# Let me recount: page1 has 2 matches + 2 non-matches. Quota is 3+3. Not met.
|
||||
# But page2 would be the same... let me think again.
|
||||
# Actually the test above is: page1 = 2+2=4 items, page2 = 2+2=4 items
|
||||
# Quotas: matches_max=3, non_matches_max=3
|
||||
# After page1: match_count=2, non_match_count=2. Neither quota met.
|
||||
# After page2: match_count=4, non_match_count=4. Both >= quota. Stop.
|
||||
# So should call page1 and page2 only.
|
||||
self.assertEqual(mock_fetch_page.call_count, 2)
|
||||
|
||||
@patch('browse.fetch_page')
|
||||
@patch('browse.time.sleep')
|
||||
def test_no_quota_fetches_all_pages(self, mock_sleep, mock_fetch_page):
|
||||
"""Without quotas, fetches all pages until pagination ends."""
|
||||
from browse import fetch_all_pages
|
||||
|
||||
page1 = {
|
||||
"events": [{"id": "e1", "title": "Event 1", "markets": []}],
|
||||
"pagination": {"totalResults": 3, "hasMore": True}
|
||||
}
|
||||
page2 = {
|
||||
"events": [{"id": "e2", "title": "Event 2", "markets": []}],
|
||||
"pagination": {"totalResults": 3, "hasMore": True}
|
||||
}
|
||||
page3 = {
|
||||
"events": [{"id": "e3", "title": "Event 3", "markets": []}],
|
||||
"pagination": {"totalResults": 3, "hasMore": False}
|
||||
}
|
||||
|
||||
mock_fetch_page.side_effect = [page1, page2, page3]
|
||||
|
||||
result = fetch_all_pages("test")
|
||||
|
||||
self.assertEqual(mock_fetch_page.call_count, 3)
|
||||
self.assertEqual(len(result["events"]), 3)
|
||||
self.assertFalse(result["partial"])
|
||||
|
||||
@patch('browse.fetch_page')
|
||||
@patch('browse.time.sleep')
|
||||
def test_early_exit_partial_true_when_stopped_early(self, mock_sleep, mock_fetch_page):
|
||||
"""Returns partial=True when stopped early due to quota."""
|
||||
from browse import fetch_all_pages
|
||||
|
||||
page1 = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match 1", "seriesSlug": "x", "gameId": "1", "markets": []},
|
||||
{"id": "m2", "title": "Match 2", "seriesSlug": "x", "gameId": "2", "markets": []},
|
||||
{"id": "m3", "title": "Match 3", "seriesSlug": "x", "gameId": "3", "markets": []},
|
||||
],
|
||||
"pagination": {"totalResults": 100, "hasMore": True}
|
||||
}
|
||||
|
||||
mock_fetch_page.return_value = page1
|
||||
|
||||
result = fetch_all_pages("test", matches_max=3, non_matches_max=3)
|
||||
|
||||
# After page1: match_count=3 >= 3, non_match_count=0 < 3. Non-match quota NOT met.
|
||||
# So should continue to page2...
|
||||
# Let me make a better test: page1 has 3 matches and 3 non-matches (both quotas met)
|
||||
# But they need to be is_match_market -> need seriesSlug+gameId OR " vs "
|
||||
# Actually the early exit checks match_count >= matches_max AND non_match_count >= non_matches_max
|
||||
# So we need both to be met.
|
||||
pass # test needs fixing, let me redo
|
||||
|
||||
@patch('browse.fetch_page')
|
||||
@patch('browse.time.sleep')
|
||||
def test_quota_one_side_only_keeps_fetching(self, mock_sleep, mock_fetch_page):
|
||||
"""If only one quota is met, keeps fetching."""
|
||||
from browse import fetch_all_pages
|
||||
|
||||
# Page 1: 3 matches, 0 non-matches (matches quota met, non_matches NOT met)
|
||||
page1 = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match 1", "seriesSlug": "x", "gameId": "1", "markets": []},
|
||||
{"id": "m2", "title": "Match 2", "seriesSlug": "x", "gameId": "2", "markets": []},
|
||||
{"id": "m3", "title": "Match 3", "seriesSlug": "x", "gameId": "3", "markets": []},
|
||||
],
|
||||
"pagination": {"totalResults": 10, "hasMore": True}
|
||||
}
|
||||
# Page 2: 0 matches, 3 non-matches (now both quotas met)
|
||||
page2 = {
|
||||
"events": [
|
||||
{"id": "n1", "title": "Non-match 1", "markets": []},
|
||||
{"id": "n2", "title": "Non-match 2", "markets": []},
|
||||
{"id": "n3", "title": "Non-match 3", "markets": []},
|
||||
],
|
||||
"pagination": {"totalResults": 10, "hasMore": True}
|
||||
}
|
||||
|
||||
mock_fetch_page.side_effect = [page1, page2]
|
||||
|
||||
result = fetch_all_pages("test", matches_max=3, non_matches_max=3)
|
||||
|
||||
self.assertEqual(mock_fetch_page.call_count, 2)
|
||||
self.assertEqual(len(result["events"]), 6)
|
||||
|
||||
|
||||
class TestBrowseEvents(unittest.TestCase):
|
||||
"""Tests for browse_events() with sort_by parameter."""
|
||||
|
||||
@patch('browse.fetch_all_pages')
|
||||
def test_browse_events_early_exit_sort_by_none(self, mock_fetch):
|
||||
"""sort_by=None uses early-exit: passes quotas to fetch_all_pages."""
|
||||
from browse import browse_events
|
||||
|
||||
mock_fetch.return_value = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match 1", "seriesSlug": "x", "gameId": "1",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "50000"}]},
|
||||
],
|
||||
"total_raw": 1,
|
||||
"partial": False,
|
||||
}
|
||||
|
||||
result = browse_events("test query", matches_max=5, non_matches_max=5, sort_by=None)
|
||||
|
||||
# Should pass quotas to fetch_all_pages for early-exit
|
||||
mock_fetch.assert_called_once()
|
||||
call_kwargs = mock_fetch.call_args
|
||||
self.assertEqual(call_kwargs[1]["matches_max"], 5)
|
||||
self.assertEqual(call_kwargs[1]["non_matches_max"], 5)
|
||||
|
||||
@patch('browse.fetch_all_pages')
|
||||
def test_browse_events_volume_sort_full_fetch(self, mock_fetch):
|
||||
"""sort_by='volume' does full fetch (no quotas passed)."""
|
||||
from browse import browse_events
|
||||
|
||||
mock_fetch.return_value = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match 1", "seriesSlug": "x", "gameId": "1",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "10000"}]},
|
||||
{"id": "m2", "title": "Match 2", "seriesSlug": "x", "gameId": "2",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "50000"}]},
|
||||
],
|
||||
"total_raw": 2,
|
||||
"partial": False,
|
||||
}
|
||||
|
||||
result = browse_events("test query", matches_max=5, non_matches_max=5, sort_by="volume")
|
||||
|
||||
# Should pass None quotas to fetch_all_pages (full fetch)
|
||||
call_kwargs = mock_fetch.call_args
|
||||
self.assertIsNone(call_kwargs[1]["matches_max"])
|
||||
self.assertIsNone(call_kwargs[1]["non_matches_max"])
|
||||
|
||||
@patch('browse.fetch_all_pages')
|
||||
def test_browse_events_volume_sort_sorts_by_volume(self, mock_fetch):
|
||||
"""sort_by='volume' sorts match events by volume descending."""
|
||||
from browse import browse_events
|
||||
|
||||
mock_fetch.return_value = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match Low", "seriesSlug": "x", "gameId": "1",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "10000",
|
||||
"bestBid": "0.50", "bestAsk": "0.52",
|
||||
"acceptingOrders": True, "closed": False}]},
|
||||
{"id": "m2", "title": "Match High", "seriesSlug": "x", "gameId": "2",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "90000",
|
||||
"bestBid": "0.50", "bestAsk": "0.52",
|
||||
"acceptingOrders": True, "closed": False}]},
|
||||
{"id": "m3", "title": "Match Mid", "seriesSlug": "x", "gameId": "3",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "50000",
|
||||
"bestBid": "0.50", "bestAsk": "0.52",
|
||||
"acceptingOrders": True, "closed": False}]},
|
||||
],
|
||||
"total_raw": 3,
|
||||
"partial": False,
|
||||
}
|
||||
|
||||
result = browse_events("test", matches_max=10, non_matches_max=10, sort_by="volume")
|
||||
|
||||
# Highest volume first
|
||||
self.assertEqual(result["match_events"][0]["id"], "m2") # vol=90000
|
||||
self.assertEqual(result["match_events"][1]["id"], "m3") # vol=50000
|
||||
self.assertEqual(result["match_events"][2]["id"], "m1") # vol=10000
|
||||
|
||||
@patch('browse.fetch_all_pages')
|
||||
def test_browse_events_api_order_preserved_when_no_sort(self, mock_fetch):
|
||||
"""sort_by=None preserves API order (no sort applied)."""
|
||||
from browse import browse_events
|
||||
|
||||
mock_fetch.return_value = {
|
||||
"events": [
|
||||
{"id": "m1", "title": "Match First", "seriesSlug": "x", "gameId": "1",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "1",
|
||||
"bestBid": "0.50", "bestAsk": "0.52",
|
||||
"acceptingOrders": True, "closed": False}]},
|
||||
{"id": "m2", "title": "Match Second", "seriesSlug": "x", "gameId": "2",
|
||||
"markets": [{"sportsMarketType": "moneyline", "volume": "999999",
|
||||
"bestBid": "0.50", "bestAsk": "0.52",
|
||||
"acceptingOrders": True, "closed": False}]},
|
||||
],
|
||||
"total_raw": 2,
|
||||
"partial": False,
|
||||
}
|
||||
|
||||
result = browse_events("test", matches_max=10, sort_by=None)
|
||||
|
||||
# API order preserved: m1 first even though m2 has higher volume
|
||||
self.assertEqual(result["match_events"][0]["id"], "m1")
|
||||
self.assertEqual(result["match_events"][1]["id"], "m2")
|
||||
|
||||
@patch('browse.fetch_all_pages')
|
||||
def test_browse_events_returns_all_required_fields(self, mock_fetch):
|
||||
"""Result dict contains all required fields."""
|
||||
from browse import browse_events
|
||||
|
||||
mock_fetch.return_value = {
|
||||
"events": [],
|
||||
"total_raw": 0,
|
||||
"partial": False,
|
||||
}
|
||||
|
||||
result = browse_events("test")
|
||||
|
||||
self.assertIn("query", result)
|
||||
self.assertIn("total_raw", result)
|
||||
self.assertIn("total_fetched", result)
|
||||
self.assertIn("total_match", result)
|
||||
self.assertIn("total_non_match", result)
|
||||
self.assertIn("match_events", result)
|
||||
self.assertIn("non_match_events", result)
|
||||
self.assertIn("partial", result)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
Reference in New Issue
Block a user