| 1 | #!/usr/bin/env python3 |
| 2 | """Isolated end-to-end API tests. No changes to the application's real database.""" |
| 3 | import concurrent.futures |
| 4 | import os |
| 5 | import signal |
| 6 | import http.cookiejar |
| 7 | import json |
| 8 | from pathlib import Path |
| 9 | import shutil |
| 10 | import socket |
| 11 | import sqlite3 |
| 12 | import subprocess |
| 13 | import tempfile |
| 14 | import time |
| 15 | import urllib.request |
| 16 | import urllib.error |
| 17 | |
| 18 | WEB = Path(__file__).resolve().parents[1] |
| 19 | ARTIFACTS = WEB / 'tests/artifacts' |
| 20 | ARTIFACTS.mkdir(exist_ok=True) |
| 21 | checks = 0 |
| 22 | |
| 23 | def check(value, label): |
| 24 | global checks |
| 25 | checks += 1 |
| 26 | assert value, label |
| 27 | |
| 28 | with tempfile.TemporaryDirectory(prefix='api-', dir=ARTIFACTS) as tmp: |
| 29 | root = Path(tmp) |
| 30 | for name in ['api.php', 'index.php', 'auth.php', 'callback.php', 'router.php']: |
| 31 | shutil.copy(WEB / name, root / name) |
| 32 | shutil.copytree(WEB / 'lib', root / 'lib', ignore=shutil.ignore_patterns('tablebase')) |
| 33 | push_file=root/'lib/Push.php' |
| 34 | push_file.write_text(push_file.read_text().replace(' $jobs=[];', " file_put_contents(dirname(__DIR__).'/data/push-events.jsonl',json_encode(array_values($events)).PHP_EOL,FILE_APPEND|LOCK_EX); return;\n $jobs=[];")) |
| 35 | def push_events(): |
| 36 | path=root/'data/push-events.jsonl' |
| 37 | return [event for line in path.read_text().splitlines() for event in json.loads(line)] if path.exists() else [] |
| 38 | shutil.copytree(WEB / 'assets/avatars', root / 'assets/avatars') |
| 39 | (root / 'data').mkdir() |
| 40 | with socket.socket() as sock: |
| 41 | sock.bind(('127.0.0.1', 0)) |
| 42 | port = sock.getsockname()[1] |
| 43 | base = f'http://127.0.0.1:{port}' |
| 44 | log = (root / 'server.log').open('w') |
| 45 | process = subprocess.Popen(['php', '-d', 'opcache.enable=0', '-S', f'127.0.0.1:{port}', '-t', str(root), str(root / 'router.php')], stdout=log, stderr=log, env={**os.environ, 'PHP_CLI_SERVER_WORKERS':'4'}, start_new_session=True) |
| 46 | class Client: |
| 47 | def __init__(self): |
| 48 | self.opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar())) |
| 49 | self.csrf = None |
| 50 | def get(self, path='/api.php'): |
| 51 | with self.opener.open(base + path) as r: |
| 52 | return json.load(r) |
| 53 | def state(self): |
| 54 | state = self.get() |
| 55 | self.csrf = state['csrf'] |
| 56 | return state |
| 57 | def post(self, action, expected=200, **fields): |
| 58 | req = urllib.request.Request(base + '/api.php', data=json.dumps({'action':action, **fields}).encode(), headers={'Content-Type':'application/json', 'X-CSRF-Token':self.csrf or ''}) |
| 59 | try: |
| 60 | response = self.opener.open(req) |
| 61 | except urllib.error.HTTPError as error: |
| 62 | response = error |
| 63 | with response: |
| 64 | check(response.status == expected, f'{action}: expected {expected}, got {response.status}') |
| 65 | return json.load(response) |
| 66 | def game(self, id): |
| 67 | return next(g for g in self.state()['games'] if g['id'] == id) |
| 68 | def game_action(self, action, id, **fields): |
| 69 | g = self.game(id) |
| 70 | return self.post(action, game=id, version=g['version'], **fields) |
| 71 | try: |
| 72 | for _ in range(100): |
| 73 | try: |
| 74 | urllib.request.urlopen(base + '/index.php').close() |
| 75 | break |
| 76 | except urllib.error.URLError: |
| 77 | time.sleep(.05) |
| 78 | config_path=root/'data/config.php' |
| 79 | check(config_path.is_file(),'First page request creates config.php') |
| 80 | generated=config_path.read_text() |
| 81 | check(all(f"'{key}' => ''" in generated for key in ['base_url','client_id','client_secret']),'Generated config fields are empty') |
| 82 | configured=generated.replace("'client_id' => ''", "'client_id' => 'fixture-client'")+'\n// Keep this server-specific comment.\n' |
| 83 | config_path.write_text(configured) |
| 84 | a, b = Client(), Client() |
| 85 | check(a.state()['user']['name'] == 'test_user_1', 'Local autologin') |
| 86 | check(config_path.read_text()==configured,'Existing configuration preserved byte-for-byte') |
| 87 | loaded=subprocess.check_output(['php','-r', |
| 88 | 'require $argv[1]; echo json_encode(config());',str(root/'lib/bootstrap.php')], |
| 89 | env={**os.environ,'MICROCHESS_BASE_URL':'https://example.test','MICROCHESS_CLIENT_ID':'environment-client','MICROCHESS_CLIENT_SECRET':'fixture-secret'},text=True) |
| 90 | check(json.loads(loaded)=={'base_url':'https://example.test','client_id':'fixture-client','client_secret':'fixture-secret'},'Empty fields use environment; configured fields take precedence') |
| 91 | b.state(); b.post('switch_user', user='test_user_2'); b.state() |
| 92 | check(b.state()['user']['name'] == 'test_user_2', 'Independent sessions') |
| 93 | check(a.state()['notificationIntroSeen'] is False,'New account has not seen notification introduction') |
| 94 | csrf=a.csrf;a.csrf='wrong';a.post('claim_notification_intro',expected=403);a.csrf=csrf |
| 95 | check(a.state()['notificationIntroSeen'] is False,'Invalid CSRF cannot consume introduction') |
| 96 | same_user=Client();same_user.state() |
| 97 | with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: |
| 98 | claims=list(executor.map(lambda client:client.post('claim_notification_intro'),[a,same_user])) |
| 99 | check(sum(claim['show'] for claim in claims)==1,'Exactly one concurrent session claims the introduction') |
| 100 | check(a.state()['notificationIntroSeen'] is True and same_user.state()['notificationIntroSeen'] is True,'Seen state persists across sessions') |
| 101 | check(a.post('claim_notification_intro')['show'] is False,'Introduction cannot be shown again') |
| 102 | check(b.state()['notificationIntroSeen'] is False,'Introduction state belongs to the account') |
| 103 | check(b.post('claim_notification_intro')['show'] is True,'Another account gets its own introduction') |
| 104 | public_key=a.get('/api.php?action=push_config')['publicKey'] |
| 105 | check(public_key==b.get('/api.php?action=push_config')['publicKey'],'Persistent server public key across sessions') |
| 106 | subscription={'endpoint':'https://fcm.googleapis.com/fcm/send/api-fixture','keys':{'p256dh':public_key,'auth':'AAAAAAAAAAAAAAAAAAAAAA'}} |
| 107 | a.post('push_subscribe',subscription=subscription) |
| 108 | a.post('push_subscribe',subscription=subscription) |
| 109 | with sqlite3.connect(root/'data/microchess.sqlite') as push_db: |
| 110 | check(push_db.execute('SELECT COUNT(*) FROM push_subscriptions').fetchone()[0]==1,'Repeated device registration does not duplicate') |
| 111 | old_csrf=a.csrf;a.csrf='wrong';a.post('push_subscribe',subscription=subscription,expected=403);a.csrf=old_csrf |
| 112 | a.post('push_subscribe',subscription={**subscription,'endpoint':'https://127.0.0.1/private'},expected=409) |
| 113 | b.post('push_unsubscribe',endpoint=subscription['endpoint']) |
| 114 | with sqlite3.connect(root/'data/microchess.sqlite') as push_db: |
| 115 | check(push_db.execute('SELECT COUNT(*) FROM push_subscriptions').fetchone()[0]==1,'Unsubscribe requires owning account') |
| 116 | a.post('push_unsubscribe',endpoint=subscription['endpoint']) |
| 117 | check(a.state()['user']['rating']==b.state()['user']['rating']==1200, 'Accounts start at 1200 Elo') |
| 118 | avatars=json.loads((root/'assets/avatars/catalog.json').read_text()) |
| 119 | check(len(avatars)==103 and sum(v['group']=='fairy' for v in avatars)==67 and sum(v['group']=='standard' for v in avatars)==36,'Retained fairy and standard avatars including White/Black') |
| 120 | check(len({Path(v['file']).stem.casefold() for v in avatars})==len(avatars),'PNG and SVG versions of a piece appear only once') |
| 121 | check(len({v['id'] for v in avatars})==len(avatars),'Avatar IDs are unique') |
| 122 | check(all((root/'assets/avatars'/v['file']).read_bytes().startswith(b'\x89PNG\r\n\x1a\n') for v in avatars),'Every selectable avatar has a local PNG') |
| 123 | initial_avatar=b.state()['user']['avatar'] |
| 124 | check(initial_avatar in {v['id'] for v in json.loads((root/'assets/avatars/catalog.json').read_text())},'Random default avatar') |
| 125 | a.post('set_avatar',avatar='blue-knight') |
| 126 | check(a.state()['user']['avatar']=='blue-knight','Avatar persists across requests') |
| 127 | check(b.state()['user']['avatar']==initial_avatar,'Avatar change affects only the signed-in user') |
| 128 | a.post('set_avatar',avatar='../../data/config.php',expected=409) |
| 129 | a.post('set_avatar',avatar='not-a-piece',expected=409) |
| 130 | a.post('set_avatar',avatar=['blue-knight'],expected=409) |
| 131 | b.post('set_avatar',avatar='purple-elephant') |
| 132 | check(b.state()['user']['avatar']=='purple-elephant','Fairy avatar can be selected') |
| 133 | b.post('set_avatar',avatar=None) |
| 134 | check(b.state()['user']['avatar'] is not None,'Random avatar reset') |
| 135 | check(any(v['id']=='white-king' for v in avatars) and any(v['id']=='black-king' for v in avatars),'White/Black standard avatars catalogued') |
| 136 | a.post('set_avatar',avatar='white-king') |
| 137 | check(a.state()['user']['avatar']=='white-king','White king avatar selectable') |
| 138 | a.post('set_avatar',avatar='blue-knight') |
| 139 | check(a.state()['user']['avatar']=='blue-knight','Restore blue knight avatar for later checks') |
| 140 | a.post('set_piece_colors',colorMode='custom',preferredColor='Red',alternativeColor='Blue') |
| 141 | user=a.state()['user'] |
| 142 | check(user['colorMode']=='custom' and user['preferredColor']=='Red' and user['alternativeColor']=='Blue','Colour preference persists') |
| 143 | a.post('set_piece_colors',colorMode='custom',preferredColor='Red',alternativeColor='Red',expected=409) |
| 144 | a.post('set_piece_colors',colorMode='custom',preferredColor='Purple',alternativeColor='Blue',expected=409) |
| 145 | # Conflict: a custom White vs b default — skins assigned when challenge accepted below |
| 146 | a.post('set_piece_colors',colorMode='custom',preferredColor='White',alternativeColor='Red') |
| 147 | b.post('set_piece_colors',colorMode='default',preferredColor='White',alternativeColor='Black') |
| 148 | a.post('switch_user', user='admin', expected=409) |
| 149 | old = a.csrf; a.csrf = 'wrong'; a.post('create_link', kind='match', expected=403); a.csrf = old |
| 150 | token = a.post('create_link', kind='friend')['url'].split('=')[1] |
| 151 | check(b.get('/api.php?invite='+token)['invite']['kind'] == 'friend', 'Friend request preview') |
| 152 | a.post('accept_link', token=token, expected=409) |
| 153 | b.post('accept_link', token=token) |
| 154 | check(len(a.state()['friends']) == len(b.state()['friends']) == 1, 'Mutual friendship') |
| 155 | check(b.state()['friends'][0]['avatar']=='blue-knight','Friends see selected avatar') |
| 156 | b.post('accept_link', token=token, expected=409) |
| 157 | a.post('challenge', friend='local:test_user_2') |
| 158 | g = b.state()['games'][0]; id = g['id'] |
| 159 | check(g['incoming'] and g['status']=='pending', 'Incoming challenge') |
| 160 | check(push_events()[-1]['kind']=='challenge' and push_events()[-1]['user']=='local:test_user_2','Challenge notification targets recipient') |
| 161 | notification_count=len(push_events()) |
| 162 | a.post('challenge', friend='local:test_user_2', expected=409) |
| 163 | a.game_action('accept', id, expected=409) |
| 164 | check(len(push_events())==notification_count,'Rejected actions never notify') |
| 165 | b.game_action('reject', id) |
| 166 | check(not a.state()['games'] and not b.state()['games'], 'Reject removes both tiles') |
| 167 | a.post('challenge', friend='local:test_user_2'); id = b.state()['games'][0]['id']; b.game_action('accept', id) |
| 168 | ga, gb = a.game(id), b.game(id) |
| 169 | check(gb['opponentAvatar']=='blue-knight','Game tile includes opponent avatar') |
| 170 | check(ga.get('pieceSkinWhite') in {'White','Black','Red','Blue','Green','Yellow'} and ga.get('pieceSkinBlack') in {'White','Black','Red','Blue','Green','Yellow'},'Game stores piece skins') |
| 171 | check(ga['pieceSkinWhite']==gb['pieceSkinWhite'] and ga['pieceSkinBlack']==gb['pieceSkinBlack'],'Both players see the same skins') |
| 172 | check(ga['displayColor']==(ga['pieceSkinWhite'] if ga['color']=='w' else ga['pieceSkinBlack']),'displayColor matches rules side skin') |
| 173 | # a prefers White (custom), b is default. Whichever side a is on: if a is white rules -> skins White vs Black; if a is black rules and wants White while b(default white) wants White -> conflict, a uses Red. |
| 174 | if ga['color']=='w': |
| 175 | check(ga['pieceSkinWhite']=='White' and ga['pieceSkinBlack']=='Black','Custom White as white rules keeps White; default black stays Black') |
| 176 | else: |
| 177 | check(ga['pieceSkinWhite']=='White' and ga['pieceSkinBlack']=='Red','Custom White as black rules yields to Red vs default White') |
| 178 | a.post('set_piece_colors',colorMode='default',preferredColor='White',alternativeColor='Black') |
| 179 | b.post('set_piece_colors',colorMode='default',preferredColor='White',alternativeColor='Black') |
| 180 | check(push_events()[-1]['kind']=='turn' and push_events()[-1]['user']==('local:test_user_1' if ga['yourTurn'] else 'local:test_user_2'),'Acceptance notifies first player') |
| 181 | check(ga['color'] != gb['color'] and ga['yourTurn'] != gb['yourTurn'], 'Opposite colors and one turn') |
| 182 | white, black = (a,b) if ga['color']=='w' else (b,a) |
| 183 | black.game_action('move', id, from_=4, to=8, expected=409) |
| 184 | current = white.game(id) |
| 185 | white.post('move', game=id, version=current['version'], **{'from':15,'to':7}, expected=409) |
| 186 | move = current['legal'][0] |
| 187 | check('analysis' not in current, 'Polling carries no obsolete evaluation data') |
| 188 | response = white.post('move', game=id, version=current['version'], **move) |
| 189 | check(response['feedback']['model'] == 'tactical-estimate' and response['feedback']['ply'] == 1, 'Confirmed move returns live tactical estimate') |
| 190 | check(response['feedback']['quality'] in [None, 'good', 'poor'], 'Only supported feedback values') |
| 191 | event=push_events()[-1] |
| 192 | check(event['kind']=='turn' and event['game']==id and event['user']==black.state()['user']['id'],'Move notifies opponent') |
| 193 | notification_count=len(push_events()) |
| 194 | white.post('move', game=id, version=current['version'], **move, expected=409) |
| 195 | check(len(push_events())==notification_count,'Stale duplicate move does not notify twice') |
| 196 | check(black.game(id)['yourTurn'], 'Turn passes') |
| 197 | check(black.game(id)['turnOrder']>current['turnOrder'],'New turn receives a later persistent queue position') |
| 198 | black.game_action('resign', id) |
| 199 | check(a.game(id)['status']=='ended' and b.game(id)['winner']==white.state()['user']['name'], 'Resignation result') |
| 200 | check(white.state()['user']['rating']==1216 and black.state()['user']['rating']==1184, 'Equal rating win transfers 16 points') |
| 201 | black.game_action('resign', id, expected=409) |
| 202 | check(black.state()['user']['ratedGames']==1, 'Duplicate result cannot change rating twice') |
| 203 | check(sum(a.state()['friends'][0][k] for k in ['wins','losses','ties'])==1, 'Stats recorded once') |
| 204 | archive=white.get('/api.php?action=history') |
| 205 | check(len(archive)==1 and archive[0]['outcome']=='win','Winner has saved game') |
| 206 | saved_id=archive[0]['id'] |
| 207 | saved=white.get(f'/api.php?action=replay&id={saved_id}') |
| 208 | check(len(saved['positions'])==2 and saved['positions'][-1]['board']==white.game(id)['state']['board'],'Replay reconstructs opening and final board') |
| 209 | check(black.get('/api.php?action=history')[0]['outcome']=='loss','Both participants can access their result') |
| 210 | check(saved['color']=='w','Replay retains player orientation') |
| 211 | check(saved['whiteName']==white.state()['user']['name'] and saved['blackName']==black.state()['user']['name'],'Replay identifies both colors') |
| 212 | token=saved['shareToken'] |
| 213 | with urllib.request.urlopen(urllib.request.Request(base+'/api.php?action=shared_replay&token='+token,headers={'Host':'example.test'})) as response: |
| 214 | public=json.load(response) |
| 215 | check(public['positions']==saved['positions'] and public['outcome']=='White won','Anonymous shared replay contains original game') |
| 216 | check(not {'a','b','csrf','opponentId'} & public.keys(),'Public replay exposes no account identifiers or session data') |
| 217 | check(white.get('/api.php?action=shared_replay&token='+token)['positions']==saved['positions'],'Signed-in player can open a shared replay') |
| 218 | check(black.get('/api.php?action=shared_replay&token='+token)['outcome']=='White won','Opponent session can open the same shared replay') |
| 219 | with white.opener.open(base+'/?replay='+token) as response: |
| 220 | page=response.read().decode() |
| 221 | check('id="replay-page"' in page and 'id="your-games"' not in page,'Signed-in visitor gets the standalone replay page') |
| 222 | check(white.get(f'/api.php?action=replay&id={saved_id}')['shareToken']==token,'Share token remains stable') |
| 223 | try: |
| 224 | urllib.request.urlopen(urllib.request.Request(base+'/api.php?action=shared_replay&token='+'0'*48,headers={'Host':'example.test'})) |
| 225 | check(False,'Unknown shared token rejected') |
| 226 | except urllib.error.HTTPError as e: |
| 227 | check(e.code==404,'Unknown shared token rejected') |
| 228 | |
| 229 | old_color = a.game(id)['color'] |
| 230 | a.game_action('rematch', id) |
| 231 | check(b.game(id)['opponentRematch'], 'Rematch notification') |
| 232 | b.game_action('rematch', id) |
| 233 | check(a.game(id)['color'] != old_color and a.game(id)['state']['ply']==0, 'Rematch swaps sides, same tile') |
| 234 | turn = a if a.game(id)['yourTurn'] else b |
| 235 | turn.game_action('offer_draw', id) |
| 236 | move = turn.game(id)['legal'][0]; turn.game_action('move',id,**move) |
| 237 | other = b if turn is a else a |
| 238 | other.game_action('accept_draw', id) |
| 239 | check(a.state()['friends'][0]['ties']==1, 'Draw stats') |
| 240 | check(white.state()['user']['rating']==1215 and black.state()['user']['rating']==1185, 'Rematch draw transfers one point to lower rated player') |
| 241 | check(a.state()['user']['ratedGames']==b.state()['user']['ratedGames']==2, 'Rematch rated separately') |
| 242 | archive=a.get('/api.php?action=history') |
| 243 | check(len(archive)==2 and archive[0]['id']>archive[1]['id'] and archive[0]['outcome']=='draw','Rematches saved separately, newest first') |
| 244 | check(white.get(f'/api.php?action=replay&id={saved_id}')['positions']==saved['positions'] and white.get(f'/api.php?action=replay&id={saved_id}')['color']==saved['color'],'Rematch preserves original replay') |
| 245 | a.game_action('rematch', id); b.game_action('exit', id) |
| 246 | check(not a.game(id)['canRematch'], 'Exit disables opponent rematch') |
| 247 | check(not b.state()['games'], 'Exit hides own tile only') |
| 248 | check(len(b.get('/api.php?action=history'))==2,'Exiting keeps saved games') |
| 249 | a.game_action('rematch', id, expected=409) |
| 250 | a.game_action('exit', id) |
| 251 | match = a.post('create_link',kind='match')['url'].split('=')[1] |
| 252 | check(b.get('/api.php?invite='+match)['invite']['kind']=='match', 'Match link modal') |
| 253 | check(b.get('/api.php?invite='+match)['invite']['kind']=='match', 'Preview/reject leaves link valid') |
| 254 | def race_accept(_): |
| 255 | req=urllib.request.Request(base+'/api.php',data=json.dumps({'action':'accept_link','token':match}).encode(),headers={'Content-Type':'application/json','X-CSRF-Token':b.csrf}) |
| 256 | try: |
| 257 | with b.opener.open(req) as response: |
| 258 | response.read() |
| 259 | return response.status |
| 260 | except urllib.error.HTTPError as error: |
| 261 | return error.code |
| 262 | with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool: |
| 263 | statuses=list(pool.map(race_accept,range(2))) |
| 264 | check(sorted(statuses)==[200,409],'Concurrent link acceptance starts only one game') |
| 265 | con=sqlite3.connect(root/'data/microchess.sqlite') |
| 266 | expired = a.post('create_link',kind='match')['url'].split('=')[1] |
| 267 | con.execute('UPDATE links SET expires=0 WHERE token=?',(expired,));con.commit() |
| 268 | b.post('accept_link',token=expired,expected=409) |
| 269 | # Server-side claim with an intended move: no requirement to play it first. |
| 270 | id=a.state()['games'][0]['id'];g=a.game(id) |
| 271 | raw=json.loads(con.execute('SELECT state FROM games WHERE id=?',(id,)).fetchone()[0]);raw['halfmove']=99 |
| 272 | con.execute('UPDATE games SET state=? WHERE id=?',(json.dumps(raw),id));con.commit() |
| 273 | turn=a if g['yourTurn'] else b |
| 274 | move=next(m for m in turn.game(id)['legal'] if m['from']==18) |
| 275 | turn.game_action('claim_draw',id,**move) |
| 276 | check(a.game(id)['reason']=='50-move rule','Intended move draw claim') |
| 277 | a.post('remove_friend',friend='local:test_user_2') |
| 278 | check(not a.state()['friends'] and not b.state()['friends'],'Mutual removal') |
| 279 | a.post('challenge',friend='local:test_user_2',expected=409) |
| 280 | exported=a.get('/api.php?action=export') |
| 281 | check(len(exported['results'])==3 and len(exported['games'])==2,'Export includes archived games/results') |
| 282 | check('token' not in exported['profile'],'No auth token in export') |
| 283 | check(exported['profile']['avatar']=='blue-knight','Data export includes avatar preference') |
| 284 | for path in ['/data/microchess.sqlite','/lib/bootstrap.php','/tests/chess.php','/data%2fmicrochess.sqlite','/.htaccess']: |
| 285 | try: |
| 286 | urllib.request.urlopen(base+path) |
| 287 | check(False,'Protected '+path) |
| 288 | except urllib.error.HTTPError as e: |
| 289 | check(e.code==403,'Protected '+path) |
| 290 | req=urllib.request.Request(base+'/api.php',headers={'Host':'production.example'}) |
| 291 | try: |
| 292 | urllib.request.urlopen(req) |
| 293 | check(False,'No production autologin') |
| 294 | except urllib.error.HTTPError as e: |
| 295 | check(e.code==401,'No production autologin') |
| 296 | # Inactivity is enforced on the server, with stale confirmation protection. |
| 297 | token=a.post('create_link',kind='match')['url'].split('=')[1] |
| 298 | inactive_id=b.post('accept_link',token=token)['game'] |
| 299 | a.game_action('stop_inactive',inactive_id,expected=409) |
| 300 | con.execute('UPDATE games SET activity_at=? WHERE id=?',(int(time.time())-8*86400,inactive_id));con.commit() |
| 301 | old=a.game(inactive_id) |
| 302 | check(old['inactiveDays']==8,'Eight inactive days shown') |
| 303 | turn=a if old['yourTurn'] else b |
| 304 | turn.game_action('move',inactive_id,**turn.game(inactive_id)['legal'][0]) |
| 305 | a.post('stop_inactive',game=inactive_id,version=old['version'],expected=409) |
| 306 | check(a.game(inactive_id)['inactiveDays']==0,'Move resets inactivity') |
| 307 | con.execute('UPDATE games SET activity_at=? WHERE id=?',(int(time.time())-7*86400,inactive_id));con.commit() |
| 308 | a.game_action('stop_inactive',inactive_id) |
| 309 | check(all(g['id']!=inactive_id for c in [a,b] for g in c.state()['games']),'Stop removes both tiles') |
| 310 | check(len(a.get('/api.php?action=export')['results'])==3,'Stopped game adds no result') |
| 311 | # Opponent statistics work without friendship; requests need recipient consent. |
| 312 | opponent=a.state()['games'][0] |
| 313 | check(opponent['opponentId']=='local:test_user_2' and sum(opponent['rivalry'].values())==3,'Non-friend opponent has historical rivalry statistics') |
| 314 | a.post('send_friend_request',friend='local:test_user_1',expected=409) |
| 315 | a.post('send_friend_request',friend='missing',expected=409) |
| 316 | a.post('send_friend_request',friend=['invalid'],expected=409) |
| 317 | old=a.csrf; a.csrf='wrong';a.post('send_friend_request',friend='local:test_user_2',expected=403);a.csrf=old |
| 318 | with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool: |
| 319 | list(pool.map(lambda _:a.post('send_friend_request',friend='local:test_user_2'),range(2))) |
| 320 | check(len(a.state()['friendRequests'])==len(b.state()['friendRequests'])==1,'Concurrent sends produce one request') |
| 321 | check(not a.state()['friendRequests'][0]['incoming'] and b.state()['friendRequests'][0]['incoming'],'Request direction is correct') |
| 322 | check(not a.state()['friends'] and not b.state()['friends'],'Sending request does not create friendship') |
| 323 | check(len(a.get('/api.php?action=export')['friend_requests'])==1,'Export includes pending requests') |
| 324 | a.post('accept_friend_request',friend='local:test_user_2',expected=409) |
| 325 | a.post('reject_friend_request',friend='local:test_user_2',expected=409) |
| 326 | b.post('send_friend_request',friend='local:test_user_1',expected=409) |
| 327 | b.post('reject_friend_request',friend='local:test_user_1') |
| 328 | check(not a.state()['friendRequests'] and not b.state()['friends'],'Rejection clears request without friendship') |
| 329 | a.post('send_friend_request',friend='local:test_user_2') |
| 330 | b.post('accept_friend_request',friend='local:test_user_1') |
| 331 | check(len(a.state()['friends'])==len(b.state()['friends'])==1,'Acceptance creates bilateral friendship') |
| 332 | check(not a.state()['friendRequests'] and not b.state()['friendRequests'],'Acceptance consumes request for both users') |
| 333 | check({k:a.state()['friends'][0][k] for k in ['wins','losses','ties']}==opponent['rivalry'],'Friend and opponent statistics match') |
| 334 | b.post('accept_friend_request',friend='local:test_user_1',expected=409) |
| 335 | a.post('send_friend_request',friend='local:test_user_2',expected=409) |
| 336 | a.post('remove_friend',friend='local:test_user_2') |
| 337 | a.post('send_friend_request',friend='local:test_user_2') |
| 338 | token=b.post('create_link',kind='friend')['url'].split('=')[1] |
| 339 | a.post('accept_link',token=token) |
| 340 | check(not a.state()['friendRequests'],'Friend link acceptance clears pending request') |
| 341 | a.post('remove_friend',friend='local:test_user_2') |
| 342 | # Queue requests survive sessions and never match the same user to themselves. |
| 343 | before_count=con.execute('SELECT count(*) FROM games').fetchone()[0] |
| 344 | a.post('join_matchmaking'); a.post('join_matchmaking') |
| 345 | check(con.execute('SELECT count(*) FROM matchmaking').fetchone()[0]==1,'One queue entry per user') |
| 346 | check(a.state()['matchmaking']['status']=='searching','Search persists on polling') |
| 347 | check(con.execute('SELECT count(*) FROM games').fetchone()[0]==before_count,'No self match') |
| 348 | a.post('cancel_matchmaking'); a.post('cancel_matchmaking') |
| 349 | check(a.state()['matchmaking'] is None,'Cancel is persistent and idempotent') |
| 350 | # Simultaneous joins produce one bilateral game, even without friendship. |
| 351 | with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool: |
| 352 | list(pool.map(lambda c:c.post('join_matchmaking'),[a,b])) |
| 353 | check(con.execute('SELECT count(*) FROM games').fetchone()[0]==before_count+1,'Concurrent joins create exactly one game') |
| 354 | check(a.state()['matchmaking'] is None and b.state()['matchmaking'] is None,'Both entries consumed') |
| 355 | matched=a.state()['games'][0] |
| 356 | check(matched['id']==b.state()['games'][0]['id'] and matched['status']=='active','Match starts for both players') |
| 357 | check(matched['color']!=b.game(matched['id'])['color'],'Matched players have opposite colors') |
| 358 | # Set ratings and elapsed time directly rather than sleeping for minutes. |
| 359 | con.execute('UPDATE ratings SET rating=1200 WHERE user_id=?',('local:test_user_1',)) |
| 360 | con.execute('UPDATE ratings SET rating=1400 WHERE user_id=?',('local:test_user_2',)); con.commit() |
| 361 | a.post('join_matchmaking'); b.post('join_matchmaking') |
| 362 | check(a.state()['matchmaking'] and b.state()['matchmaking'],'200 point gap initially waits') |
| 363 | con.execute('UPDATE matchmaking SET joined=? WHERE user_id=?',(int(time.time())-120,'local:test_user_1')) |
| 364 | con.execute('UPDATE matchmaking_clock SET checked=0');con.commit() |
| 365 | check(a.state()['matchmaking'] is not None,'Both players must allow rating gap') |
| 366 | con.execute('UPDATE matchmaking SET joined=?',(int(time.time())-120,)) |
| 367 | con.execute('UPDATE matchmaking_clock SET checked=0');con.commit() |
| 368 | check(a.state()['matchmaking'] is None and b.state()['matchmaking'] is None,'Activity matches after two minutes of widening') |
| 369 | a.post('join_matchmaking') |
| 370 | con.execute('UPDATE matchmaking SET joined=?',(int(time.time())-86400,));con.commit() |
| 371 | b.post('join_matchmaking') |
| 372 | check(a.state()['matchmaking']['status']=='expired','Expired registration is excluded') |
| 373 | a.post('join_matchmaking') |
| 374 | check(a.state()['matchmaking']['status']=='searching','Expired search can restart') |
| 375 | con.execute('UPDATE ratings SET rating=1800 WHERE user_id=?',('local:test_user_2',)) |
| 376 | con.execute('UPDATE matchmaking SET joined=?',(int(time.time())-3600,)) |
| 377 | con.execute('UPDATE matchmaking_clock SET checked=0');con.commit() |
| 378 | check(a.state()['matchmaking'] is not None,'Rating tolerance capped at 500') |
| 379 | a.post('cancel_matchmaking');b.post('cancel_matchmaking') |
| 380 | # An unrelated user's page activity processes the entire pool, oldest first, |
| 381 | # choosing the closest eligible opponent and leaving unmatched entries intact. |
| 382 | now=int(time.time()) |
| 383 | for uid,rating,joined in [('queue:oldest',1200,now-300),('queue:far',1290,now-200),('queue:near',1220,now-100)]: |
| 384 | con.execute('INSERT INTO users VALUES(?,?)',(uid,uid)) |
| 385 | con.execute('INSERT INTO ratings VALUES(?,?,0)',(uid,rating)) |
| 386 | con.execute('INSERT INTO matchmaking VALUES(?,?)',(uid,joined)) |
| 387 | con.execute('UPDATE matchmaking_clock SET checked=0');con.commit() |
| 388 | a.state() |
| 389 | pair=con.execute('SELECT a,b FROM games ORDER BY id DESC LIMIT 1').fetchone() |
| 390 | check(set(pair)=={'queue:oldest','queue:near'},'Whole pool prefers closest opponent for oldest entry') |
| 391 | check(con.execute('SELECT user_id FROM matchmaking').fetchall()==[('queue:far',)],'Unmatched entry remains queued') |
| 392 | check(con.execute('SELECT count(*) FROM rating_changes').fetchone()[0]==3,'Every completed result has one rating ledger entry') |
| 393 | con.close() |
| 394 | with sqlite3.connect(root/'data/microchess.sqlite') as archive_db: |
| 395 | private_id=archive_db.execute("INSERT INTO results(game_id,a,b,winner,reason,state,ended) SELECT game_id,'queue:oldest','queue:near',NULL,'Draw','{}',ended FROM results WHERE id=?",(saved_id,)).lastrowid |
| 396 | archive_db.execute("INSERT INTO replays(result_id,white,moves,piece_skin_white,piece_skin_black) SELECT ?, 'queue:oldest', moves, piece_skin_white, piece_skin_black FROM replays WHERE result_id=?",(private_id,saved_id)) |
| 397 | outsider_token=os.urandom(24).hex() |
| 398 | archive_db.execute('INSERT INTO replay_links(result_id,token) VALUES(?,?)',(private_id,outsider_token)) |
| 399 | check(all(r['id']!=private_id for r in a.get('/api.php?action=history')),'History excludes other players games') |
| 400 | check(a.get('/api.php?action=shared_replay&token='+outsider_token)['shared'] is True,'Signed-in outsider can view another pair\'s shared replay') |
| 401 | try: |
| 402 | a.get(f'/api.php?action=replay&id={private_id}') |
| 403 | check(False,'Other players replay unavailable') |
| 404 | except urllib.error.HTTPError as e: |
| 405 | check(e.code==404,'Other players replay unavailable') |
| 406 | with sqlite3.connect(root/'data/microchess.sqlite') as archive_db: |
| 407 | check(archive_db.execute('SELECT length(moves) FROM replays WHERE result_id=?',(saved_id,)).fetchone()[0]==23,'One move uses two bytes plus initial position') |
| 408 | archive_db.execute('UPDATE results SET ended=? WHERE id=?',(int(time.time())-10*365*86400,saved_id)) |
| 409 | check(any(r['id']==saved_id for r in a.get('/api.php?action=history')),'Old replay remains in history without a retention limit') |
| 410 | check(a.get(f'/api.php?action=replay&id={saved_id}')['positions']==saved['positions'],'Old replay remains fully playable') |
| 411 | check(any(r['id']==saved_id for r in a.get('/api.php?action=export')['replays']),'Old replay remains available in exports') |
| 412 | # Exercise the real OAuth state/session/redirect code against a local auth stub. |
| 413 | auth_bootstrap=root/'lib/bootstrap.php' |
| 414 | auth_bootstrap.write_text(auth_bootstrap.read_text().replace( |
| 415 | " $ch=curl_init('https://auth.timfalken.com'.$path);", |
| 416 | " return $path==='/api/me'?['user'=>['id'=>'oauth-fixture','username'=>'oauth_fixture']]:['access_token'=>'fixture-token','expires_in'=>86400];\n $ch=curl_init('https://auth.timfalken.com'.$path);")) |
| 417 | config_path.write_text(config_path.read_text().replace("'client_secret' => ''", "'client_secret' => 'fixture-secret'")) |
| 418 | class NoRedirect(urllib.request.HTTPRedirectHandler): |
| 419 | def redirect_request(self, req, fp, code, msg, headers, newurl): return None |
| 420 | oauth=urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()),NoRedirect()) |
| 421 | def redirect(path): |
| 422 | try: |
| 423 | oauth.open(base+path) |
| 424 | raise AssertionError('Expected redirect') |
| 425 | except urllib.error.HTTPError as error: |
| 426 | check(error.code==302,'OAuth redirects: '+error.read().decode()) |
| 427 | return error.headers['Location'] |
| 428 | from urllib.parse import urlsplit,parse_qs |
| 429 | login=redirect('/auth.php?game=42&invite='+'a'*48) |
| 430 | oauth_state=parse_qs(urlsplit(login).query)['state'][0] |
| 431 | callback=redirect('/callback.php?state='+oauth_state+'&code=fixture') |
| 432 | check(parse_qs(urlsplit(callback).query)=={'game':['42'],'invite':['a'*48]},'OAuth round trip preserves game and invitation') |
| 433 | check(urlsplit(callback).path=='/','OAuth returns to main screen') |
| 434 | print(f'API: {checks} assertions passed.') |
| 435 | finally: |
| 436 | os.killpg(process.pid,signal.SIGTERM);process.wait();log.close() |
projects-timfalken-com microchess