doormile_milderapp/test/trip_tabs_pinned_test.dart

import 'package:flutter/material.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:flutter_test/flutter_test.dart';

import 'package:miler/views/Dashboard/home/trip.dart';
import 'package:miler/views/Dashboard/home/trip_tabs.dart';

/// The Trip 1 / 2 / 3 bar is a **pinned** sliver on Home: it scrolls up with the
/// page, then holds at the top while the stops pass underneath, so switching
/// trips never costs a scroll back up.
///
/// Two things here are worth a test.
///
/// **The extent is computed, and computed height is the classic way to clip a
/// control.** A pinned sliver must declare a fixed height, and [TripTabs]
/// deliberately has none — its own comment records that a hard `54.h` overflowed
/// by a few pixels at large font settings. `extentFor` therefore derives the
/// height from the text scale and over-estimates on purpose. If that estimate is
/// ever short, the tabs are clipped inside the header, silently. So it is
/// measured here from 1.0× to 2.0×.
///
/// **Pinning itself.** That the bar holds position while content scrolls under
/// it is the entire point of the change, and a one-word edit (`pinned: false`)
/// undoes it invisibly.
void main() {
  // The view is forced to 390x844 logical below, so gestures must aim inside
  // that box — x=400 would land outside the viewport and hit nothing.
  const inViewport = Offset(195, 500);

  const aboveKey = ValueKey('above');
  const belowKey = ValueKey('below');

  final trips = [
    Trip.fromStops(id: 't1', stops: [
      {'orderid': 'A', 'type': 'pickup', 'pickupcustomer': 'Sri Balaji'},
    ]),
    Trip.fromStops(id: 't2', stops: [
      {'orderid': 'B', 'type': 'delivery', 'pickupcustomer': 'Anand'},
    ]),
  ];

  /// Pumps the real delegate inside a scroll view, at a given text scale, and
  /// hands back the extent it reserved.
  Future<double> pump(
    WidgetTester tester, {
    double textScale = 1.0,
    ValueChanged<int>? onSelect,
  }) async {
    tester.view.physicalSize = const Size(1170, 2532);
    tester.view.devicePixelRatio = 3.0;
    addTearDown(tester.view.resetPhysicalSize);
    addTearDown(tester.view.resetDevicePixelRatio);

    double? captured;

    await tester.pumpWidget(
      ScreenUtilInit(
        designSize: const Size(390, 844),
        builder: (_, _) => MaterialApp(
          builder: (context, child) => MediaQuery(
            data: MediaQuery.of(context)
                .copyWith(textScaler: TextScaler.linear(textScale)),
            child: child!,
          ),
          home: Scaffold(
            body: Builder(
              builder: (context) {
                captured = TripTabsHeader.extentFor(context);
                return CustomScrollView(
                  slivers: [
                    SliverToBoxAdapter(
                      child: Container(
                        key: aboveKey,
                        height: 300,
                        color: Colors.amber,
                      ),
                    ),
                    SliverPersistentHeader(
                      pinned: true,
                      delegate: TripTabsHeader(
                        extent: captured!,
                        trips: trips,
                        selectedIndex: 1,
                        onSelect: onSelect ?? (_) {},
                      ),
                    ),
                    SliverToBoxAdapter(
                      child: Container(
                        key: belowKey,
                        height: 2000,
                        color: Colors.grey,
                      ),
                    ),
                  ],
                );
              },
            ),
          ),
        ),
      ),
    );
    await tester.pumpAndSettle();
    return captured!;
  }

  group('reserved extent fits the tabs', () {
    // 2.0 is beyond Android's slider but within what a determined user can set,
    // and it is the case the original 54.h bug was reported against.
    for (final scale in [1.0, 1.15, 1.3, 1.5, 1.75, 2.0]) {
      testWidgets('at ${scale}x text scale', (tester) async {
        final extent = await pump(tester, textScale: scale);

        expect(tester.takeException(), isNull,
            reason: 'the tabs must not overflow the reserved extent');

        final tabs = tester.getSize(find.byType(TripTabs));
        expect(tabs.height, lessThanOrEqualTo(extent + 0.01),
            reason: 'tabs are ${tabs.height} tall but only $extent was '
                'reserved — the bar would be clipped');

        // Over-reserving is the safe direction, but not by a wasteful amount.
        expect(extent - tabs.height, lessThan(14),
            reason: 'reserving $extent for ${tabs.height} of content is '
                'more dead space than the safety margin intends');

        // All three slots are still rendered and readable at this scale.
        for (final label in ['Trip 1', 'Trip 2', 'Trip 3']) {
          expect(find.text(label), findsOneWidget);
        }
      });
    }
  });

  group('pinning', () {
    testWidgets('the bar holds at the top while content scrolls under it',
        (tester) async {
      await pump(tester);
      final atRest = tester.getRect(find.byType(TripTabs));
      // It starts below the 300pt block above it, not stuck to the top.
      expect(atRest.top, greaterThan(200));

      await tester.dragFrom(inViewport, const Offset(0, -600));
      await tester.pumpAndSettle();

      final pinned = tester.getRect(find.byType(TripTabs));
      expect(pinned.top, lessThan(atRest.top),
          reason: 'it should travel up with the page first');
      expect(pinned.top, lessThan(40),
          reason: 'and then hold near the top of the viewport');

      // Scrolling further does not move it again.
      await tester.dragFrom(inViewport, const Offset(0, -600));
      await tester.pumpAndSettle();
      expect(tester.getRect(find.byType(TripTabs)), pinned);
    });

    testWidgets('what sits above it does scroll away', (tester) async {
      await pump(tester);
      expect(find.byKey(aboveKey), findsOneWidget);

      await tester.dragFrom(inViewport, const Offset(0, -900));
      await tester.pumpAndSettle();

      // The summary / shift / metrics block is meant to leave; only the control
      // stays. A sliver that has left the viewport and its cache is unmounted.
      expect(find.byKey(aboveKey), findsNothing);
      expect(find.byType(TripTabs), findsOneWidget);
    });

    testWidgets('a tab is still tappable once pinned', (tester) async {
      var picked = -1;
      await pump(tester, onSelect: (i) => picked = i);

      await tester.dragFrom(inViewport, const Offset(0, -900));
      await tester.pumpAndSettle();

      await tester.tap(find.text('Trip 1'));
      await tester.pumpAndSettle();
      expect(picked, 0,
          reason: 'switching trips from deep in the list is the whole point');
    });
  });
}