Files
pipelines/app/test/perf/background_work_bench_test.dart
T
alan e7d00b85ff Runs: running run and stage durations tick live
One shared ElapsedClock (single timer, only while a visible running item
is watched and the app is visible; cadence follows formatDuration
precision) and a LiveElapsedBuilder that repaints only its own text.
Running list rows, the Summary Duration and running timeline visits
tick. A stage start re-reads the open detail, since step deltas carry
no started_at. Fixture ?running=1 for captures.
2026-11-04 17:43:29 +00:00

257 lines
8.9 KiB
Dart

// Measures wasted background work outside the chat transcript: timers kept
// alive by list rows, rebuilds per minute tick, offstage tabs' work and the
// rebuilds a burst of run events causes. Each scenario prints its numbers
// (`BENCH ...`) and asserts the budgets the shared clock and the narrowed
// notifications keep.
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/runs/data/runs_repository.dart';
import 'package:pipelines_app/features/runs/ui/runs_controller.dart';
import 'package:pipelines_app/features/runs/ui/runs_list.dart';
import 'package:pipelines_app/shell/adaptive_shell.dart';
import 'package:pipelines_app/shell/destination.dart';
import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart';
import 'package:pipelines_app/ui/text/relative_time_label.dart';
class _Gateway implements ApiGateway {
final controller = StreamController<JsonMap>.broadcast(sync: true);
List<JsonMap> runs = [];
@override
Stream<JsonMap> get frames => controller.stream;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async => {
'runs': [for (final run in runs) Map<String, dynamic>.of(run)],
};
}
/// Counts element rebuilds by widget type while installed.
class _Rebuilds {
final Map<Type, int> counts = {};
void install() => debugOnRebuildDirtyWidget = (element, _) => counts.update(
element.widget.runtimeType,
(n) => n + 1,
ifAbsent: () => 1,
);
void uninstall() => debugOnRebuildDirtyWidget = null;
int of(Type type) => counts[type] ?? 0;
int get total => counts.values.fold(0, (a, b) => a + b);
void reset() => counts.clear();
}
/// Tracks every Timer created in its zone (one-shot and periodic).
class _Timers {
final List<Timer> created = [];
int get active => created.where((t) => t.isActive).length;
late final ZoneSpecification spec = ZoneSpecification(
createTimer: (self, parent, zone, duration, f) {
final timer = parent.createTimer(zone, duration, f);
created.add(timer);
return timer;
},
createPeriodicTimer: (self, parent, zone, period, f) {
final timer = parent.createPeriodicTimer(zone, period, f);
created.add(timer);
return timer;
},
);
}
List<JsonMap> _runs(int count, DateTime now) => [
for (var i = 0; i < count; i++)
{
'id': i + 1,
'name': 'Pipeline ${i % 7}',
'title': 'Run ${i + 1}',
'status': i < 20 ? 'running' : 'succeeded',
'executing': i < 20,
'completed_steps': 1,
// The lifecycle fields a server list row carries.
'notify_mode': 'auto',
'resource_wait': null,
'cancel_requested': false,
'cleanup_unconfirmed': false,
// Every 20 seconds back: the newest rows change label each minute.
'created_at': now.subtract(Duration(seconds: 20 * i)).toIso8601String(),
},
];
// The app passes a stable tear-off (`_select`), never a fresh closure.
void _open(num _) {}
void main() {
late _Gateway gateway;
late RunsController controller;
final rebuilds = _Rebuilds();
setUp(() async {
gateway = _Gateway()..runs = _runs(300, DateTime.now());
controller = RunsController(RunsRepository(gateway));
controller.listen(gateway.frames);
await controller.load();
});
tearDown(() async {
rebuilds.uninstall();
controller.dispose();
await gateway.controller.close();
});
Widget shell(AppDestination destination) => MaterialApp(
home: AdaptiveShell(
destination: destination,
destinationBodies: {
AppDestination.runs: (_) => AnimatedBuilder(
animation: controller,
builder: (_, _) =>
RunsList(controller: controller, onSelected: _open),
),
AppDestination.pipelines: (_) => const Center(child: Text('pipelines')),
},
),
);
/// Sends frame [i] of a busy stream: most frames repeat a running row's
/// current state; every fifth advances its step count.
void frame(int i) {
final id = 1 + i % 20;
final row = gateway.runs[id - 1];
if (i % 5 == 0) row['completed_steps'] = 2 + i;
gateway.controller.add({
'type': 'run_event',
'run_id': id,
'status': 'running',
'completed_steps': row['completed_steps'],
});
}
Future<void> sizeView(WidgetTester tester) async {
tester.view.physicalSize = const Size(400, 900);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
}
testWidgets('300-run list: timers and rebuilds per minute tick', (
tester,
) async {
await sizeView(tester);
final timers = _Timers();
await runZoned(zoneSpecification: timers.spec, () async {
await tester.pumpWidget(shell(AppDestination.runs));
await tester.pump();
final labels = find.byType(RelativeTimeLabel).evaluate().length;
final active = timers.active;
// Measure one whole minute after the first tick, wherever it falls.
await tester.pump(const Duration(minutes: 1));
await tester.pump();
final created = timers.created.length;
rebuilds
..reset()
..install();
await tester.pump(const Duration(minutes: 1));
await tester.pump();
final perMinute = timers.created.length - created;
rebuilds.uninstall();
// ignore: avoid_print
print(
'BENCH list300 mountedLabels=$labels activeTimers=$active '
'labelRebuildsPerMinute=${rebuilds.of(RelativeTimeLabel)} '
'totalRebuildsPerMinute=${rebuilds.total} '
'timersScheduledPerMinute=$perMinute',
);
// One shared minute clock for the relative times and one shared clock
// for the 20 running rows' ticking durations; never a timer per row.
expect(active, lessThanOrEqualTo(2));
expect(perMinute, lessThanOrEqualTo(61));
await tester.pumpWidget(const SizedBox());
expect(timers.active, 0);
});
});
testWidgets('offstage Runs tab: minute ticks and run events', (tester) async {
await sizeView(tester);
final timers = _Timers();
await runZoned(zoneSpecification: timers.spec, () async {
await tester.pumpWidget(shell(AppDestination.runs));
await tester.pump();
await tester.pumpWidget(shell(AppDestination.pipelines));
await tester.pump(const Duration(seconds: 1)); // fade-through done
final active = timers.active;
rebuilds
..reset()
..install();
await tester.pump(const Duration(minutes: 2));
await tester.pump();
final tick = rebuilds.of(RelativeTimeLabel);
rebuilds.reset();
for (var i = 0; i < 50; i++) {
frame(i);
await tester.pump();
}
await tester.pump();
rebuilds.uninstall();
// ignore: avoid_print
print(
'BENCH offstage activeTimers=$active labelRebuildsIn2Minutes=$tick '
'burst50: runsListRebuilds=${rebuilds.of(RunsList)} '
'shellBarRebuilds=${rebuilds.of(FloatingDestinationBar)} '
'totalRebuilds=${rebuilds.total}',
);
expect(tick, 0);
expect(rebuilds.of(FloatingDestinationBar), 0);
await tester.pumpWidget(const SizedBox());
expect(timers.active, 0);
});
});
testWidgets('visible Runs tab: a 50-frame run_event burst', (tester) async {
await sizeView(tester);
var notifications = 0;
controller.addListener(() => notifications++);
await tester.pumpWidget(shell(AppDestination.runs));
await tester.pump();
final rows = find.byType(RunListRow).evaluate().length;
rebuilds
..reset()
..install();
final wall = Stopwatch()..start();
// Frames arrive between frames on a real socket: pump after each.
for (var i = 0; i < 50; i++) {
frame(i);
await tester.pump();
}
await tester.pump();
rebuilds.uninstall();
final seconds = wall.elapsed.inSeconds;
// ignore: avoid_print
print(
'BENCH visibleBurst50 controllerNotifications=$notifications '
'runsListRebuilds=${rebuilds.of(RunsList)} '
'runRowRebuilds=${rebuilds.of(RunListRow)} '
'shellBarRebuilds=${rebuilds.of(FloatingDestinationBar)} '
'totalRebuilds=${rebuilds.total}',
);
final top = rebuilds.counts.entries.toList()
..sort((a, b) => b.value - a.value);
// ignore: avoid_print
print(
'BENCH top ${top.take(15).map((e) => '${e.key}=${e.value}').join(' ')}',
);
// Only the ten frames that advance a step change anything visible.
expect(notifications, lessThanOrEqualTo(10));
// Each notification rebuilds the one row whose run changed, not every
// built row (16 rows rebuilt per notification before memoized rows). An
// executing row also rebuilds when its wall-clock duration text moves to
// the next second, at most once per second the burst took.
expect(
rebuilds.of(RunListRow),
lessThanOrEqualTo(notifications + rows * (seconds + 1)),
);
await tester.pumpWidget(const SizedBox());
});
}