from __future__ import annotations

from concurrent.futures import ThreadPoolExecutor
from http.cookiejar import CookieJar
import io
import json
import sqlite3
from pathlib import Path
import threading
from urllib.error import HTTPError
from urllib.request import build_opener, HTTPCookieProcessor, Request

from PIL import Image
import pytest

from pallet.structure_review import ReviewApplication, ReviewError, ReviewServer, ReviewStore, accepts_webp, etag_matches, sha256, within


@pytest.fixture
def app(tmp_path):
    source, dataset, media, reviews = (tmp_path/p for p in ('source', 'dataset', 'media', 'reviews'))
    source.mkdir(); dataset.mkdir(); media.mkdir()
    Image.new('L', (180, 90), 150).save(dataset/'frame.png')
    (source/'threshold_masks').mkdir()
    rows = []
    for i in range(3):
        key = f'key{i}'
        Image.new('L', (100, 30), 255).save(source/f'threshold_masks/{key}.png')
        rows.append({'target_key': key, 'target_id': f'frame::box:{i:04d}', 'frame_id': 'frame',
            'bbox': {'x': 10., 'y': 20., 'width': 100., 'height': 30.}, 'integer_bbox': [10, 20, 110, 50],
            'image': 'frame.png', 'final_class_id': i+1, 'final_class': f'Class {i+1}', 'split': 'train',
            'group_id': 'group1', 'support_leg_count': 3 if i != 2 else None,
            'closure_type': 'chuan' if i != 2 else None, 'structure_label_source': 'threshold_xy_projections',
            'structure_priority_review': i == 2, 'structure_is_seed': i == 1, 'structure_visual_rechecked': False,
            'structure_projection_evidence': {'threshold_mask': f'threshold_masks/{key}.png',
                'foreground_mask': None, 'selected_trial': {'vertical_projection': [.8, .1, .8]},
                'flags': [], 'thresholds': [100, 110, 120]}})
    (source/'targets.jsonl').write_text(''.join(json.dumps(r)+'\n' for r in rows))
    (source/'output_manifest.json').write_text(json.dumps({'state': 'complete',
        'files': {'targets.jsonl': sha256(source/'targets.jsonl')}}))
    return ReviewApplication(source, reviews, dataset, media)


def decision(**changes):
    data = {'status': 'approved', 'support_leg_count': 3, 'closure_type': 'chuan',
        'reviewer': '测试审核员', 'note': '', 'expected_revision': 0}
    return dict(data, **changes)


def batch_decision(app, keys=('key0', 'key1', 'key2'), **changes):
    data = dict(decision(), source_targets_sha256=app.source_hash,
        items=[{'target_key': key, 'expected_revision': app.store.get(key)['revision']} for key in keys])
    data.update(changes)
    return data


def test_confirm_persists_audited_labels_without_touching_proposals(app):
    digest = sha256(app.source/'targets.jsonl')
    result = app.store.save('key0', decision())
    assert result['revision'] == 1 and result['status'] == 'approved'
    assert app.store.history('key0') == [result]
    restarted = ReviewApplication(app.source, app.store.directory, app.dataset, app.media)
    assert restarted.store.get('key0') == result
    assert restarted.access_key == app.access_key
    assert sha256(app.source/'targets.jsonl') == digest
    assert app.statistics() == {'total': 3, 'approved': 1, 'deferred': 0, 'pending': 2, 'corrected': 0}


def test_changes_and_partial_unknowns_are_separate_from_approval(app):
    app.store.save('key0', decision(support_leg_count=4, closure_type='tian'))
    app.store.save('key1', decision(status='deferred', closure_type=None, note='下部遮挡'))
    assert app.statistics()['corrected'] == 1
    assert app.statistics()['approved'] == 1
    assert app.statistics()['deferred'] == 1
    result = app.detail('key0')
    assert result['target']['support_leg_count'] == 3
    assert result['review']['support_leg_count'] == 4


def test_reset_keeps_history_and_restores_pending(app):
    app.store.save('key0', decision())
    result = app.store.save('key0', decision(status='pending', expected_revision=1))
    assert result['support_leg_count'] is None and result['closure_type'] is None
    assert result['revision'] == 2
    assert len(app.store.history('key0')) == 2
    assert app.statistics()['pending'] == 3


@pytest.mark.parametrize('changes', [
    {'status': 'anything'}, {'support_leg_count': True}, {'support_leg_count': 5},
    {'support_leg_count': 3.0}, {'closure_type': 'closed'}, {'support_leg_count': None},
    {'closure_type': None}, {'reviewer': ''}, {'reviewer': 'x'*81}, {'note': 'x'*2001},
    {'expected_revision': -1}, {'expected_revision': True}, {'expected_revision': None},
    {'reviewer': {}}, {'note': []},
])
def test_invalid_labels_never_become_human_confirmation(app, changes):
    with pytest.raises(ReviewError) as caught: app.store.save('key0', decision(**changes))
    assert caught.value.status == 400
    assert not app.store.history('key0')


def test_two_devices_cannot_overwrite_each_other(app):
    def save(leg):
        try: return app.store.save('key0', decision(support_leg_count=leg))
        except ReviewError as e: return e.status
    with ThreadPoolExecutor(max_workers=2) as pool:
        results = list(pool.map(save, (2, 4)))
    assert sum(isinstance(r, dict) for r in results) == 1
    assert 409 in results
    assert len(app.store.history('key0')) == 1


def test_database_refuses_binding_to_other_source(app):
    with pytest.raises(ValueError, match='different frozen'):
        ReviewStore(app.store.directory, {'source_targets_sha256': 'different'})
    assert app.store.get('key0')['revision'] == 0


def test_filters_use_human_labels_for_reviewed_rows(app):
    app.store.save('key0', decision(support_leg_count=4, closure_type='tian'))
    assert app.queue({})['keys'] == ['key1', 'key2']
    assert app.queue({'state': ['approved'], 'legs': ['4'], 'closure': ['tian']})['keys'] == ['key0']
    assert app.queue({'state': ['all'], 'group': ['2'], 'priority': ['seed']})['keys'] == ['key1']
    assert app.queue({'priority': ['1'], 'legs': ['unknown']})['keys'] == ['key2']
    assert app.queue({'q': ['box:0002']})['keys'] == ['key2']


def test_image_crops_native_pixels_and_context_does_not_modify_file(app):
    original = sha256(app.dataset/'frame.png')
    crop = Image.open(io.BytesIO(app.image('key0', 'crop')))
    assert crop.size == (100, 30)
    full = Image.open(io.BytesIO(app.image('key0', 'context')))
    assert full.size == (180, 90)
    assert full.getpixel((10, 20)) == (255, 92, 109)
    assert sha256(app.dataset/'frame.png') == original
    with pytest.raises(ReviewError): app.image('key0', '../../access_key.txt')
    with pytest.raises(ValueError): within(app.source, '../reviews/access_key.txt')


def test_exports_distinguish_machine_suggestions_human_confirmation_and_training(app):
    app.store.save('key0', decision(reviewer='=HYPERLINK("test")', note='@unsafe'))
    app.store.save('key1', decision(status='deferred', closure_type=None))
    rows = [json.loads(r) for r in app.export('jsonl').splitlines()]
    assert len(rows) == 3
    assert rows[0]['human_confirmed'] is True
    assert rows[1]['human_confirmed'] is False and rows[2]['human_confirmed'] is False
    assert all(r['training_eligible'] is False for r in rows)
    assert rows[0]['source_targets_sha256'] == app.source_hash
    csv = app.export('csv').decode('utf-8-sig')
    assert "'@unsafe" in csv and "'=HYPERLINK" in csv
    assert app.store.get('key0')['note'] == '@unsafe'


def test_changed_proposal_bytes_are_rejected(app):
    with (app.source/'targets.jsonl').open('a') as stream: stream.write('\n')
    with pytest.raises(ValueError, match='changed after delivery'):
        ReviewApplication(app.source, app.store.directory, app.dataset, app.media)


def test_review_directory_must_not_overlap_sources(app):
    with pytest.raises(ValueError, match='separate'):
        ReviewApplication(app.source, app.source/'human', app.dataset, app.media)


@pytest.fixture
def web(app):
    server = ReviewServer(('127.0.0.1', 0), app)
    thread = threading.Thread(target=server.serve_forever, daemon=True); thread.start()
    base = f'http://127.0.0.1:{server.server_port}'
    opener = build_opener(HTTPCookieProcessor(CookieJar()))
    def request(path, data=None, headers=None, method=None):
        defaults = {'Content-Type': 'application/json', 'X-Review-Request': '1'} if data is not None else {}
        defaults.update(headers or {})
        req = Request(base+path, data=json.dumps(data).encode() if data is not None else None,
            headers=defaults, method=method)
        try:
            with opener.open(req, timeout=10) as r: return r.status, r.read(), r.headers
        except HTTPError as r: return r.code, r.read(), r.headers
    yield request, app, base
    server.shutdown(); server.server_close(); thread.join()


def test_http_shell_is_public_but_data_and_images_require_auth(web):
    request, app, _ = web
    assert request('/')[0] == 200
    assert request('/app.js')[0] == 200
    assert request('/healthz')[0] == 200
    for path in ('/api/bootstrap', '/api/queue', '/api/targets/key0', '/media/key0/crop', '/api/export'):
        assert request(path)[0] == 401
    assert request('/api/login', {'key': '错误访问码'})[0] == 401
    status, _, headers = request('/api/login', {'key': app.access_key})
    assert status == 200
    assert 'HttpOnly' in headers['Set-Cookie'] and 'SameSite=Strict' in headers['Set-Cookie']
    assert request('/api/bootstrap')[0] == 200
    assert request('/media/key0/crop')[2]['Content-Type'] == 'image/png'
    assert request('/../reviews/access_key.txt')[0] == 404
    assert request('/api/reviews/unknown', decision())[0] == 404


def test_http_save_revision_conflict_export_and_history(web):
    request, app, _ = web
    request('/api/login', {'key': app.access_key})
    assert request('/api/reviews/key0', decision())[0] == 200
    assert request('/api/reviews/key0', decision())[0] == 409
    status, raw, _ = request('/api/targets/key0')
    assert status == 200 and len(json.loads(raw)['history']) == 1
    status, raw, headers = request('/api/export?format=csv')
    assert status == 200 and raw.startswith(b'\xef\xbb\xbf')
    assert 'attachment' in headers['Content-Disposition']
    assert request('/api/export?format=html')[0] == 400


def test_csrf_and_content_type_protection(web):
    request, app, base = web
    request('/api/login', {'key': app.access_key})
    assert request('/api/reviews/key0', decision(), {'Origin': 'https://elsewhere.invalid'})[0] == 403
    assert request('/api/reviews/key0', decision(), {'Sec-Fetch-Site': 'cross-site'})[0] == 403
    assert request('/api/reviews/key0', decision(), {'X-Review-Request': ''})[0] == 403
    assert request('/api/reviews/key0', decision(), {'Content-Type': 'text/plain'})[0] == 415
    assert request('/api/reviews/key0', decision(), {'Origin': base})[0] == 200


def test_malformed_cookies_and_json_are_rejected_without_server_errors(web):
    request, app, _ = web
    assert request('/api/bootstrap', headers={'Cookie': '[]="malformed"'})[0] == 401
    assert request('/api/login', ['not-an-object'])[0] == 400
    assert request('/api/login', {'key': '中文访问码'})[0] == 401
    request('/api/login', {'key': app.access_key})
    assert request('/api/reviews/key0', ['not-an-object'])[0] == 400


def test_tunnel_https_sessions_use_secure_cookie(web):
    request, app, _ = web
    status, _, headers = request('/api/login', {'key': app.access_key}, {'X-Forwarded-Proto': 'https'})
    assert status == 200 and '; Secure' in headers['Set-Cookie']


def test_static_assets_are_mobile_ready_and_have_no_external_dependencies(web):
    request, _, _ = web
    _, raw, headers = request('/')
    html = raw.decode()
    assert 'viewport-fit=cover' in html and 'maximum-scale' not in html
    assert 'https://' not in html
    assert "frame-ancestors 'none'" in headers['Content-Security-Policy']
    css = request('/app.css')[1].decode()
    assert 'safe-area-inset-bottom' in css and '@media(max-width:700px)' in css
    assert 'min-height:44px' in css


def test_projection_charts_are_vector_based_and_do_not_block_on_gpu_canvas(web):
    request, _, _ = web
    html = request('/')[1].decode()
    javascript = request('/app.js')[1].decode()
    assert '<svg id="vertical-plot"' in html and '<svg id="horizontal-plot"' in html
    assert 'getContext(' not in javascript
    assert "node('polyline'" in javascript


def test_interactions_precede_images_and_progress_does_not_use_remaining_queue(web):
    request, _, _ = web
    html = request('/')[1].decode()
    javascript = request('/app.js')[1].decode()
    assert html.index('id="review-controls"') < html.index('id="target-image"')
    for name in ('leg-choices', 'closure-choices', 'approve', 'defer', 'prev', 'skip', 'notes-toggle', 'evidence-toggle', 'zoom'):
        assert html.index(f'id="{name}"') < html.index('id="target-image"')
    assert 'id="filter-dialog"' in html and 'id="note-dialog"' in html and 'id="evidence-dialog"' in html
    assert 'S.totalTargets = stats.total' in javascript
    assert "$('position').textContent" not in javascript
    assert "$('total-count').textContent = S.totalTargets.toLocaleString()" in javascript


def test_iphone13_layout_uses_logical_pixels_dynamic_height_and_all_safe_insets(web):
    request, _, _ = web
    html = request('/')[1].decode()
    css = request('/app.css')[1].decode()
    assert '?v=iphone13-' in html
    assert '390x844 CSS screen' in css
    for side in ('top', 'right', 'bottom', 'left'):
        assert f'--review-safe-{side}:env(safe-area-inset-{side},0px)' in css
        assert f'var(--review-safe-{side})' in css
    assert 'height:100dvh' in css
    assert '(max-height:430px) and (orientation:landscape)' in css


def test_unknown_defaults_are_explicit_and_only_remember_successful_confirmations(web):
    request, _, _ = web
    html = request('/')[1].decode()
    javascript = request('/app.js')[1].decode()
    assert 'id="inherited-hint"' in html and '沿用上条' in html
    assert 'function selectionDefaults(detail, previous)' in javascript
    assert "const reviewed = detail.review.status !== 'pending'" in javascript
    assert 'if (values[key] === null)' in javascript
    assert 'previous.target_key !== detail.target.target_key' in javascript
    assert "if (review.status === 'approved') rememberConfirmed(review)" in javascript
    assert 'reference.source_targets_sha256 !== S.sourceHash' in javascript
    assert 'if (isConfirmed(detail.review)) rememberConfirmed(detail.review)' in javascript
    assert 'forgetConfirmed(key)' in javascript


def test_batch_confirmation_is_shared_atomic_and_audited(app):
    original = sha256(app.source/'targets.jsonl')
    result = app.save_batch(batch_decision(app, support_leg_count=4, closure_type='tian'))
    assert len(result['reviews']) == 3 and result['stats']['approved'] == 3
    assert result['batch_id']
    for key in app.keys:
        review = app.store.get(key)
        assert review['support_leg_count'] == 4 and review['closure_type'] == 'tian'
        assert review['revision'] == 1 and review['status'] == 'approved'
        event = app.store.history(key)[0]
        assert event['batch_id'] == result['batch_id'] and event['batch_size'] == 3
        assert event['batch_target_keys'] == ['key0', 'key1', 'key2']
    assert sha256(app.source/'targets.jsonl') == original
    restarted = ReviewApplication(app.source, app.store.directory, app.dataset, app.media)
    assert restarted.statistics()['approved'] == 3


def test_batch_conflict_in_last_item_leaves_all_other_items_untouched(app):
    data = batch_decision(app)
    old = app.store.save('key2', decision(support_leg_count=2))
    with pytest.raises(ReviewError) as error: app.save_batch(data)
    assert error.value.status == 409
    assert app.store.get('key0')['revision'] == app.store.get('key1')['revision'] == 0
    assert app.store.history('key0') == app.store.history('key1') == []
    assert app.store.get('key2') == old and len(app.store.history('key2')) == 1


def test_batch_write_failure_rolls_back_reviews_and_events(app):
    with app.store.connect() as db:
        db.execute("""CREATE TRIGGER simulate_write_failure BEFORE INSERT ON events
            WHEN NEW.target_key='key1' BEGIN SELECT RAISE(ABORT,'simulated disk failure'); END""")
    with pytest.raises(sqlite3.IntegrityError): app.save_batch(batch_decision(app))
    assert app.store.all() == {}
    assert all(not app.store.history(key) for key in app.keys)


@pytest.mark.parametrize('items', [[], [{}]*10, [None], [{'target_key': 'key0', 'expected_revision': True}],
    [{'target_key': 'key0', 'expected_revision': -1}], [{'target_key': {}, 'expected_revision': 0}],
    [{'target_key': 'key0', 'expected_revision': 0}]*2])
def test_invalid_batch_members_rejected_before_any_write(app, items):
    with pytest.raises(ReviewError) as error: app.save_batch(batch_decision(app, items=items))
    assert error.value.status == 400 and not app.store.all()


def test_batch_source_and_identity_are_checked_before_saving(app):
    for changes, status in (({'source_targets_sha256': 'wrong-source'}, 409),
            ({'items': [{'target_key': 'unknown', 'expected_revision': 0}]}, 404),
            ({'closure_type': None}, 400), ({'note_mode': 'invalid'}, 400)):
        with pytest.raises(ReviewError) as error: app.save_batch(batch_decision(app, **changes))
        assert error.value.status == status and not app.store.all()


def test_batch_preserves_individual_notes_unless_explicitly_edited(app):
    app.store.save('key0', decision(note='原备注甲'))
    app.store.save('key1', decision(note='原备注乙'))
    app.save_batch(batch_decision(app, support_leg_count=2, note='未编辑的显示值'))
    assert [app.store.get(k)['note'] for k in app.keys] == ['原备注甲', '原备注乙', '']
    app.save_batch(batch_decision(app, note_mode='replace', note='统一新备注'))
    assert all(app.store.get(k)['note'] == '统一新备注' for k in app.keys)


def test_batch_defer_and_reset_are_not_false_approvals(app):
    app.save_batch(batch_decision(app, status='deferred', closure_type=None))
    assert app.statistics()['deferred'] == 3 and app.statistics()['approved'] == 0
    app.save_batch(batch_decision(app, status='pending'))
    assert app.statistics()['pending'] == 3
    assert all(app.store.get(k)['support_leg_count'] is None for k in app.keys)


def test_batch_endpoint_auth_csrf_capability_and_transaction(web):
    request, app, _ = web
    assert request('/api/review-batches', batch_decision(app))[0] == 401
    request('/api/login', {'key': app.access_key})
    assert json.loads(request('/api/bootstrap')[1])['max_batch_size'] == 9
    assert request('/api/review-batches', batch_decision(app), {'Origin': 'https://invalid.example'})[0] == 403
    status, raw, _ = request('/api/review-batches', batch_decision(app))
    assert status == 200 and len(json.loads(raw)['reviews']) == 3
    assert app.statistics()['approved'] == 3


@pytest.mark.parametrize('header,expected', [('',False), ('image/png,*/*',False),
    ('image/avif,image/webp,image/png',True), ('image/webp;q=0',False),
    ('image/webp;q=0.8',True), ('image/webp;q=invalid',False),
    ('image/webp;q=NaN',False), ('image/webp;q=2',False)])
def test_webp_negotiation_requires_explicit_supported_format(header, expected):
    assert accepts_webp(header) is expected


def test_lossless_image_variants_preserve_pixels_dimensions_and_original_files(app):
    frame = Image.new('RGB', (180,90))
    frame.putdata([(v,v,v) for v in ((x*17+y*9)%256 for y in range(90) for x in range(180))])
    frame.save(app.dataset/'frame.png')
    mask = Image.new('L',(100,30))
    mask.putdata([255 if y<5 or x<10 or 45<x<55 or x>90 else 0 for y in range(30) for x in range(100)])
    mask.save(app.source/'threshold_masks/key0.png')
    protected = {p:sha256(p) for p in (app.dataset/'frame.png',app.source/'threshold_masks/key0.png')}
    for kind in ('crop','context','threshold'):
        pixels, raw = app.image_pixels('key0',kind)
        if raw is None:
            stream=io.BytesIO();pixels.save(stream,format='PNG');raw=stream.getvalue()
        for data in app.image_variants('key0',kind).values():
            if data is None: continue
            with Image.open(io.BytesIO(data)) as decoded:
                assert decoded.size == pixels.size
                assert decoded.convert('RGBA').tobytes() == pixels.convert('RGBA').tobytes()
        data,mime = app.transfer_image('key0',kind,True)
        assert len(data)<=len(raw) and mime in ('image/png','image/webp')
    assert all(sha256(p)==digest for p,digest in protected.items())
    assert app.image_variants.cache_info().maxsize == 512


def test_transparent_mask_fallback_preserves_alpha_and_hidden_colors(app):
    mask=Image.new('RGBA',(100,30),(255,0,0,0));mask.putpixel((50,15),(10,20,30,128))
    mask.save(app.source/'threshold_masks/key0.png')
    data,mime=app.transfer_image('key0','threshold',True)
    assert mime=='image/png'
    with Image.open(io.BytesIO(data)) as decoded: assert decoded.convert('RGBA').tobytes()==mask.tobytes()


def test_webp_encoder_failure_keeps_png_available(app,monkeypatch):
    original=Image.Image.save
    def save(image,fp,format=None,**kwargs):
        if format=='WEBP': raise OSError('simulated unavailable encoder')
        return original(image,fp,format=format,**kwargs)
    monkeypatch.setattr(Image.Image,'save',save)
    data,mime=app.transfer_image('key0','crop',True)
    assert mime=='image/png' and data.startswith(b'\x89PNG')


def test_embedded_color_profile_is_not_dropped_by_transmission(app):
    frame=Image.new('RGB',(180,90),(90,90,90))
    profile=b'embedded-profile-for-metadata-roundtrip'*16
    frame.save(app.dataset/'frame.png',icc_profile=profile)
    for data in app.image_variants('key0','crop').values():
        if data is None:continue
        with Image.open(io.BytesIO(data)) as decoded:assert decoded.info['icc_profile']==profile


def test_media_cache_is_private_versioned_and_auth_checked_before_304(web):
    request,app,_=web
    request('/api/login',{'key':app.access_key})
    assert json.loads(request('/api/bootstrap')[1])['image_version']==app.image_version
    url='/media/key0/crop?v='+app.image_version
    status,data,headers=request(url,headers={'Accept':'image/webp,image/png'})
    assert status==200 and headers['Vary']=='Accept'
    assert 'private' in headers['Cache-Control'] and 'immutable' in headers['Cache-Control']
    assert 'public' not in headers['Cache-Control'] and len(headers.get_all('Cache-Control'))==1
    etag=headers['ETag']
    status,body,conditional=request(url,headers={'Accept':'image/webp,image/png','If-None-Match':'W/'+etag})
    assert status==304 and body==b'' and conditional['ETag']==etag
    assert request(url,headers={'Cookie':'','If-None-Match':etag})[0]==401
    status,png,h=request(url,headers={'Accept':'image/webp;q=0,image/png'})
    assert status==200 and h['Content-Type']=='image/png' and png.startswith(b'\x89PNG')
    assert 'no-cache' in request('/media/key0/crop')[2]['Cache-Control']
    assert request('/api/bootstrap')[2]['Cache-Control']=='no-store'


def test_etag_lists_and_weak_comparison():
    assert etag_matches('"other", W/"current"','"current"')
    assert etag_matches('*','"current"')
    assert not etag_matches('"other"','"current"')


def test_previous_button_uses_actual_page_history_not_shrinking_pending_position(web):
    request,_,_=web
    javascript=request('/app.js')[1].decode()
    assert "$('prev').disabled = S.busy || !previousPage()" in javascript
    assert "$('prev').onclick = () => navigatePage('back')" in javascript
    assert "stored('navigation-v1'" in javascript
    assert 'saved.source_targets_sha256 !== S.sourceHash' in javascript
    assert 'const departing=S.currentPage || S.restoredPage || legacyPage' in javascript
    assert 'if (!options.replaying && departing && !samePage(departing,arriving))' in javascript


def test_history_navigation_cannot_override_current_grid_or_save_hidden_peers(web):
    request,_,_=web
    javascript=request('/app.js')[1].decode()
    follow=javascript.split('async function followPage(',1)[1].split('function rememberConfirmed(',1)[0]
    last=javascript.split("$('last-reviewed').onclick",1)[1].split("$('approve').onclick",1)[0]
    assert 'S.grid=' not in follow.replace(' ','')
    assert 'S.grid=' not in last.replace(' ','')
    assert 'keys.length>S.grid.rows*S.grid.cols' in javascript
    assert 'scopeKeys:destination.page.scopeKeys' in follow
    assert 'const historyNext=S.forwardTrail.length ? nextPage() : null' in javascript
    assert "if (historyNext) await followPage(historyNext,'forward')" in javascript
    assert "items: details.map(d => ({target_key: d.target.target_key" in javascript
