ai-app/iris/transcript-fixture/tests/fence_fling.rs

//! Layer 1 for Iris's 2026-09-08 "flinging doesn't work in horizontal
//! scroll areas": a real markdown fence in the real transcript screen,
//! flicked sideways, has to keep moving after the finger leaves.
//!
//! The fence is pushed here rather than hunted for in the bench fixture,
//! so the test knows which row it is pressing and where. The `Scroll` it
//! asserts on is found by walking what is actually drawn -- there is no
//! handle to it from the outside, and a coordinate would only prove that
//! *something* moved.

use iris::harness::{Harness, TouchAction};
use iris::prelude::*;
use transcript_fixture::{PHONE_FRAME_MS, PHONE_SCALE, phone_size};

/// The horizontal scroll area drawn inside `top..bottom`, with the box
/// it was drawn at -- a fence is the only thing in a transcript that pans
/// sideways. Found by walking what is actually drawn, because there is no
/// handle to a fence's own `Scroll` from the outside and a bare
/// coordinate would only prove that *something* moved.
fn fence_scroll_in(h: &Harness, top: f32, bottom: f32) -> Option<(WidgetId, PixelRegion)> {
    h.render
        .active
        .keys()
        .copied()
        .filter(|&id| {
            h.rsc
                .ui
                .widgets
                .get_dyn(id)
                .and_then(|w| w.as_any().downcast_ref::<Scroll>())
                .is_some_and(|s| s.axis() == Axis::X)
        })
        .find_map(|id| {
            let r = h.render.window_region(&id, &h.rsc)?;
            (r.top_left.y >= top && r.bot_right.y <= bottom).then_some((id, r))
        })
}

fn amt(h: &Harness, id: WidgetId) -> f32 {
    h.rsc
        .ui
        .widgets
        .get_dyn(id)
        .and_then(|w| w.as_any().downcast_ref::<Scroll>())
        .expect("the fence's scroll area is still drawn")
        .amt()
}

#[test]
fn a_flick_across_a_code_fence_keeps_moving_after_the_finger_leaves() {
    use client_core::transcript_fold::{TranscriptItem, TranscriptRow};

    let mut h = Harness::new(phone_size(), PHONE_SCALE);
    let opened = transcript_fixture::open(&mut h.rsc, &mut h.state).expect("the fixture folds");
    let screen = opened.screen;
    h.frame(0);
    h.frame(PHONE_FRAME_MS);

    let fence = TranscriptRow::Single(TranscriptItem::AssistantMsg {
        seq: 9_000_000,
        text: "```\none two three four five six seven eight nine ten eleven twelve \
               thirteen fourteen fifteen sixteen seventeen eighteen twenty twentyone\n```"
            .to_string(),
        settled: true,
    });
    screen.push_row(&mut h.rsc, &fence);
    (screen.list)(&mut h.rsc).jump_to_end();
    h.frame(100);
    h.frame(108);

    let key = transcript_ui::row::row_key(&fence.key());
    let (top, bottom) = (screen.list)(&mut h.rsc)
        .extent(key)
        .expect("the fence row is on screen");
    let (fence_scroll, box_) = fence_scroll_in(&h, top, bottom)
        .expect("the pushed fence draws a horizontal scroll area of its own");
    assert_eq!(amt(&h, fence_scroll), 0.0, "a fence opens at its start");

    // Down the middle of the fence's own box, so the press is on the
    // text inside the scroll area rather than on the row's sender label.
    let y = (box_.top_left.y + box_.bot_right.y) / 2.0;

    // A flick sideways: four samples 8ms apart, accelerating, then the
    // finger leaves.
    h.touch(TouchAction::Down, Vec2::new(900.0, y), 200);
    for (i, x) in [860.0, 800.0, 720.0, 620.0].into_iter().enumerate() {
        h.touch(TouchAction::Move, Vec2::new(x, y), 208 + 8 * i as u64);
    }
    h.touch(TouchAction::Up, Vec2::new(620.0, y), 240);

    let at_release = amt(&h, fence_scroll);
    assert!(
        at_release > 0.0,
        "the flick itself must have panned the fence, got {at_release}"
    );

    // Frames for the next half second, with nothing touching the screen.
    let mut t = 240;
    while t <= 740 {
        h.frame(t);
        t += PHONE_FRAME_MS;
    }
    let coasted = amt(&h, fence_scroll);
    assert!(
        coasted > at_release + 1.0,
        "the fence stopped dead at the release: {at_release} -> {coasted}"
    );

    // ...and it settles rather than running forever.
    let settled = coasted;
    while t <= 4_000 {
        h.frame(t);
        t += PHONE_FRAME_MS;
    }
    let after = amt(&h, fence_scroll);
    assert!(
        after >= settled,
        "a fling must not run backwards: {settled} -> {after}"
    );
    let last = after;
    h.frame(t);
    assert_eq!(last, amt(&h, fence_scroll), "the fling never settled");
}