e7d00b85ff
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.
257 lines
8.9 KiB
Dart
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());
|
|
});
|
|
}
|