| import json |
| import sqlite3 |
| import concurrent.futures |
| import httpx |
| import pytest |
| from rl_posttrain.rewards.base import parse_scores,SLOTS |
| from rl_posttrain.rewards.protocol import payload,group_content |
| from rl_posttrain.rewards.api_group import RequestStore,APIGroupScorer |
| from rl_posttrain.io import read_json |
|
|
| @pytest.mark.parametrize("invalid",['{"video_1":true,"video_2":1,"video_3":2,"video_4":3}','{"video_1":NaN,"video_2":1,"video_3":2,"video_4":3}','{"video_1":101,"video_2":1,"video_3":2,"video_4":3}','{"video_1":1}', '```json\n{"video_1":1,"video_2":1,"video_3":2,"video_4":3}\n```','{"video_1":1,"video_1":2,"video_2":1,"video_3":2,"video_4":3}']) |
| def test_strict_parser(invalid): |
| with pytest.raises((ValueError,TypeError)):parse_scores(invalid) |
|
|
| def test_one_request_full_frames_and_mapping(group,config): |
| p,key,m=payload(group,config);images=[x for x in p["messages"][0]["content"] if x["type"]=="image_url"] |
| assert len(images)==124;assert "PRIVATE_LABEL_SENTINEL" not in json.dumps(p) |
| assert list(m)==list(SLOTS) |
| parsed=parse_scores('{"video_4":40,"video_2":20,"video_1":10,"video_3":30}') |
| assert list(parsed.values())==[10,20,30,40] |
| _,mapping=group_content(group,config,["video_4","video_2","video_1","video_3"]) |
| assert mapping["video_1"]==m["video_4"] |
|
|
| def test_atomic_32_claims_only_one_owner(tmp_path): |
| store=RequestStore(tmp_path/"cache.db") |
| with concurrent.futures.ThreadPoolExecutor(max_workers=32) as pool: |
| rows=list(pool.map(lambda _:store.claim("key","group",1),range(32))) |
| assert sum(row[0]=="claimed" for row in rows)==1 |
| assert sum(row[0]=="inflight" for row in rows)==31 |
|
|
| def test_cache_success_no_repeat(group,config,tmp_path): |
| calls=[] |
| def handle(request): |
| calls.append(request);return httpx.Response(200,json={"choices":[{"message":{"content":json.dumps(dict(zip(SLOTS,[10,20,30,40])))}}]}) |
| scorer=APIGroupScorer(config,tmp_path/"run",1,httpx.MockTransport(handle)) |
| assert scorer.score(group)==scorer.score(group);assert len(calls)==1 |
|
|
| def test_401_fatal_and_response_retained(group,config,tmp_path): |
| calls=[] |
| def handle(req):calls.append(1);return httpx.Response(401,json={"error":"unauthorized"}) |
| scorer=APIGroupScorer(config,tmp_path/"run",1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError):scorer.score(group) |
| assert len(calls)==1;assert (group/"teacher/response_raw.json").exists() |
|
|
| def test_unknown_timeout_no_rebilling(group,config,tmp_path): |
| calls=[] |
| def handle(req):calls.append(1);raise httpx.ReadTimeout("unknown",request=req) |
| scorer=APIGroupScorer(config,tmp_path/"run",1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError):scorer.score(group) |
| with pytest.raises(RuntimeError):scorer.score(group) |
| assert len(calls)==1;assert (group/"teacher/unknown.json").exists() |
|
|
| def test_429_retry_then_success(group,config,tmp_path): |
| calls=[] |
| def handle(req): |
| calls.append(1) |
| if len(calls)==1:return httpx.Response(429,headers={"retry-after":"0"},json={"error":"rate"}) |
| return httpx.Response(200,json={"choices":[{"message":{"content":json.dumps(dict(zip(SLOTS,[10,20,30,40])))}}]}) |
| scorer=APIGroupScorer(config,tmp_path/"run",1,httpx.MockTransport(handle));scorer.score(group) |
| assert len(calls)==2 |
|
|
| @pytest.mark.parametrize('status',[401,413]) |
| def test_html_fatal_response_retained_without_retry(group,config,tmp_path,status): |
| calls=[] |
| def handle(req): |
| calls.append(1) |
| return httpx.Response(status,text='<html>gateway rejection</html>',headers={'content-type':'text/html'}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError,match=f'HTTP {status}'):scorer.score(group) |
| assert len(calls)==1 |
| report=read_json(group/'teacher/response_raw.json') |
| assert report['http_status']==status and not report['response_is_json'] |
| assert report['response_text']=='<html>gateway rejection</html>' |
| with scorer.store.connect() as db: |
| assert db.execute('select status,error,attempts from requests').fetchone()==('failed',f'fatal_http_{status}',1) |
|
|
| def test_html_gateway_retry_has_durable_status(group,config,tmp_path): |
| calls=[] |
| def handle(req): |
| calls.append(1) |
| if len(calls)==1:return httpx.Response(502,text='<html>bad gateway</html>',headers={'retry-after':'0'}) |
| return httpx.Response(200,json={'choices':[{'message':{'content':json.dumps(dict(zip(SLOTS,[10,20,30,40])))}}]}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle));scorer.score(group) |
| assert len(calls)==2 |
| assert read_json(group/'teacher/response_attempt_01.json')['http_status']==502 |
| assert read_json(group/'teacher/retry_attempt_01.json')['reason']=='retryable_http_502' |
|
|
| def test_read_error_is_unknown_not_resubmitted(group,config,tmp_path): |
| calls=[] |
| def handle(req):calls.append(1);raise httpx.ReadError('stream interrupted',request=req) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError,match='status unknown'):scorer.score(group) |
| with pytest.raises(RuntimeError,match='reconciliation'):scorer.score(group) |
| assert len(calls)==1 |
|
|
| def test_connection_failures_leave_bounded_attempt_reports(group,config,tmp_path,monkeypatch): |
| monkeypatch.setattr('rl_posttrain.rewards.api_group.time.sleep',lambda _:None) |
| calls=[] |
| def handle(req):calls.append(1);raise httpx.ConnectError('unavailable',request=req) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError,match='exhausted'):scorer.score(group) |
| assert len(calls)==config['reward']['max_retries']+1 |
| report=read_json(group/f"teacher/retry_attempt_{len(calls):02d}.json") |
| assert report['reason']=='ConnectError' and report['retry_exhausted'] |
|
|
| def test_formal_report_accepts_retained_html_gateway_responses(group,tmp_path): |
| from rl_posttrain.formal_report import build |
| from rl_posttrain.io import write_json |
| run=tmp_path/'run';(run/'groups').mkdir(parents=True) |
| (run/'groups'/group.name).symlink_to(group,target_is_directory=True) |
| write_json(run/'plan/cursor.json',{'cursor':0,'api_consumed':0,'local_consumed':0,'inflight':None}) |
| write_json(run/'plan/epoch_order.json',{'order':['0']}) |
| write_json(run/'plan/stage_state.json',{'stage':'paused_API_reconciliation'}) |
| write_json(group/'teacher/response_attempt_01.json',{'http_status':504,'response':None,'response_text':'gateway timeout'}) |
| report=build(run) |
| assert report['saved_provider_responses']==1 |
| assert report['reported_provider_usage']=={} and not report['formal_completed'] |
|
|
| def test_explicit_retry_keeps_history_and_scores_once(group,config,tmp_path): |
| from rl_posttrain.io import write_json |
| calls=[] |
| def handle(req): |
| calls.append(1) |
| return httpx.Response(200,json={'choices':[{'message':{'content':json.dumps(dict(zip(SLOTS,[10,20,30,40])))}}]}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| _,key,_=payload(group,config) |
| scorer.store.claim(key,group.name,1) |
| for _ in range(6):scorer.store.attempt(key) |
| scorer.store.finish(key,'unknown',error='user_pause') |
| write_json(group/'teacher/response_attempt_01.json',{'historical':True}) |
| scorer.store.authorize_retry(key,1,'User requested one full-group availability probe') |
| assert scorer.score(group)==scorer.score(group) |
| assert len(calls)==1 |
| assert read_json(group/'teacher/response_attempt_01.json')=={'historical':True} |
| assert read_json(group/'teacher/response_attempt_07.json')['attempt']==7 |
| with scorer.store.connect() as db: |
| assert db.execute('select status,attempts from requests').fetchone()==('succeeded',7) |
| assert db.execute('select baseline_attempts,attempt_limit from retry_authorizations').fetchone()==(6,7) |
| with pytest.raises(ValueError):scorer.store.authorize_retry(key,1,'Do not rebill cached success') |
|
|
| def test_single_probe_authorization_does_not_enable_configured_retries(group,config,tmp_path): |
| calls=[] |
| def handle(req):calls.append(1);raise httpx.ConnectError('offline',request=req) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| _,key,_=payload(group,config);scorer.store.claim(key,group.name,1) |
| for _ in range(6):scorer.store.attempt(key) |
| scorer.store.finish(key,'failed',error='exhausted') |
| scorer.store.authorize_retry(key,1,'Single probe only') |
| with pytest.raises(RuntimeError,match='exhausted'):scorer.score(group) |
| with pytest.raises(RuntimeError,match='Cached failed'):scorer.score(group) |
| assert len(calls)==1 |
| assert read_json(group/'teacher/retry_attempt_07.json')['retry_exhausted'] |
|
|
| @pytest.mark.parametrize('status',[504,524]) |
| def test_upstream_timeout_is_unknown_without_rebilling(group,config,tmp_path,status): |
| calls=[] |
| def handle(req):calls.append(1);return httpx.Response(status,text='Gateway timeout',headers={'cf-ray':'test-ray'}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError,match='outcome unknown'):scorer.score(group) |
| with pytest.raises(RuntimeError,match='reconciliation'):scorer.score(group) |
| assert len(calls)==1 |
| assert read_json(group/'teacher/unknown.json')['reason']==f'upstream_timeout_http_{status}' |
| assert read_json(group/'teacher/response_raw.json')['cf_ray']=='test-ray' |
|
|
| def test_stream_scores_and_usage_preserve_canonical_request(group,config,tmp_path,monkeypatch): |
| monkeypatch.setenv('STATEPLAY_API_STREAM','1') |
| calls=[] |
| parts=[{'id':'stream-test','choices':[{'index':0,'delta':{'content':'{"video_1":10,"video_2":20,'},'finish_reason':None}]}, |
| {'choices':[{'index':0,'delta':{'content':'"video_3":30,"video_4":40}'},'finish_reason':'stop'}]}, |
| {'choices':[],'usage':{'prompt_tokens':123,'completion_tokens':20,'total_tokens':143}}] |
| body=': heartbeat\n\n'+''.join('data: '+json.dumps(p)+'\n\n' for p in parts)+'data: [DONE]\n\n' |
| def handle(req): |
| wire=json.loads(req.content);calls.append(wire) |
| assert wire['stream'] and wire['stream_options']=={'include_usage':True} |
| assert len([p for p in wire['messages'][0]['content'] if p['type']=='image_url'])==124 |
| return httpx.Response(200,text=body,headers={'content-type':'text/event-stream'}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| assert scorer.score(group)==dict(zip(SLOTS,[10.,20.,30.,40.])) |
| assert len(calls)==1 |
| assert 'stream' not in read_json(group/'teacher/request_payload.json') |
| report=read_json(group/'teacher/response_raw.json') |
| assert report['assembled_from_stream'] and report['response']['usage']['total_tokens']==143 |
| assert (group/'teacher/stream_attempt_01.jsonl').exists() |
|
|
| def test_partial_stream_is_retained_and_never_retried(group,config,tmp_path,monkeypatch): |
| monkeypatch.setenv('STATEPLAY_API_STREAM','1') |
| calls=[] |
| def handle(req): |
| calls.append(1) |
| return httpx.Response(200,text='data: {"choices":[{"delta":{"content":"partial"}}]}\n\n',headers={'content-type':'text/event-stream'}) |
| scorer=APIGroupScorer(config,tmp_path/'run',1,httpx.MockTransport(handle)) |
| with pytest.raises(RuntimeError,match='status unknown'):scorer.score(group) |
| with pytest.raises(RuntimeError,match='reconciliation'):scorer.score(group) |
| assert len(calls)==1 |
| assert 'partial' in (group/'teacher/stream_attempt_01.jsonl').read_text() |
|
|
