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.
This commit is contained in:
2026-11-04 17:43:29 +00:00
parent fa6c0864db
commit e7d00b85ff
15 changed files with 733 additions and 42 deletions
@@ -239,4 +239,20 @@ bool runDetailNeedsFullSync(JsonMap frame) {
stepLifecycleRank(stepStatus) == 2;
}
/// A step delta carries no timestamps, so a visit that started running after
/// the detail was read has no `started_at` (and no elapsed time) until the
/// detail is read again.
bool runDetailLacksStepStart(JsonMap? detail, JsonMap frame) {
final step = frame['step'];
if (step is! Map || _word(step['status']) != 'running') return false;
final steps = detail?['steps'];
if (steps is! List) return false;
for (final known in steps.whereType<Map>()) {
if (known['sequence'] == step['sequence']) {
return _blank(known['started_at']);
}
}
return true;
}
String _word(dynamic value) => '${value ?? ''}'.trim().toLowerCase();
@@ -23,6 +23,7 @@ typedef DetailVisit = ({
String outcome,
String target,
String? duration,
DateTime? runningSince,
});
/// The run's primary label: the stored title, else the pipeline name, and only
@@ -149,6 +150,7 @@ List<DetailVisit> detailTimeline(dynamic steps) {
outcome: '${step['outcome'] ?? ''}'.trim(),
target: '${step['target'] ?? ''}'.trim(),
duration: _visitDuration(step),
runningSince: _visitRunningSince(step),
);
}(),
];
@@ -205,6 +207,14 @@ String? _visitDuration(Map step) {
return seconds < 0 ? null : formatDuration(seconds);
}
/// When a running visit started, so its row can show the elapsed time; null
/// for a visit that is not running, finished, or recorded no start.
DateTime? _visitRunningSince(Map step) {
if ('${step['status'] ?? ''}'.trim().toLowerCase() != 'running') return null;
if ('${step['finished_at'] ?? ''}'.trim().isNotEmpty) return null;
return DateTime.tryParse('${step['started_at'] ?? ''}'.trim());
}
String _text(dynamic value, String fallback) {
final text = '${value ?? ''}'.trim();
return text.isEmpty ? fallback : text;
@@ -23,7 +23,10 @@ typedef DetailSummaryRow = ({
/// `summaryRows` in the web client does. A run with no pipeline id shows its
/// recorded pipeline name, and shows no Pipeline row at all when it recorded
/// neither.
List<DetailSummaryRow> detailSummaryRows(JsonMap run) {
///
/// An executing run with no recorded finish shows its elapsed Duration up to
/// [now]; without [now] it has none.
List<DetailSummaryRow> detailSummaryRows(JsonMap run, {DateTime? now}) {
final rows = <DetailSummaryRow>[];
void add(
String label,
@@ -48,10 +51,10 @@ List<DetailSummaryRow> detailSummaryRows(JsonMap run) {
add('Content hash', _text(run['content_hash']), monospace: true);
add('Started', formatLocalTimestamp(_text(run['created_at'])));
add('Finished', formatLocalTimestamp(_text(run['finished_at'])));
final seconds = durationSeconds(
_text(run['created_at']),
_text(run['finished_at']),
);
final since = detailRunningSince(run);
final seconds = since != null
? now?.difference(since).inSeconds
: durationSeconds(_text(run['created_at']), _text(run['finished_at']));
if (seconds != null) add('Duration', formatDuration(seconds));
final retryOf = _number(run['retry_of'])?.toInt() ?? 0;
if (retryOf > 0) add('Retry of', 'run $retryOf');
@@ -82,6 +85,15 @@ String detailSummaryIdentity(JsonMap run) {
'${visits(completed, 'completed')}';
}
/// When the run started, while it is executing and has no recorded finish;
/// null otherwise, so its Duration is the recorded one (or none).
DateTime? detailRunningSince(JsonMap run) {
if (run['executing'] != true || _text(run['finished_at']) != null) {
return null;
}
return parseInstant(_text(run['created_at']));
}
String? _text(dynamic value) {
if (value == null) return null;
final text = '$value'.trim();
@@ -9,6 +9,7 @@ import 'run_field_body.dart';
import '../../../ui/adaptive/host.dart';
import '../../../ui/layout/facts_grid.dart';
import '../../../ui/layout/sticky_section.dart';
import '../../../ui/text/live_elapsed_builder.dart';
import '../../../ui/text/monospace.dart';
import '../../../ui/adaptive/floating_bar_layout.dart';
@@ -37,10 +38,12 @@ Widget runDetailSummaryTab({
// The top bar's subtitle already names the run's pipeline (and its title
// opens it), so a Pipeline fact would only repeat it.
final pipelineInBar = '${run['name'] ?? ''}'.trim().isNotEmpty;
final facts = [
for (final row in rows)
List<DetailSummaryRow> facts(DateTime now) => [
for (final row in detailSummaryRows(run, now: now))
if (!row.block && !(pipelineInBar && row.label == 'Pipeline')) row,
];
// An executing run's Duration ticks; only the facts grid rebuilds with it.
final runningSince = detailRunningSince(run);
return CustomScrollView(
key: const Key('run-detail-tab-body-summary'),
slivers: [
@@ -63,21 +66,27 @@ Widget runDetailSummaryTab({
),
// The facts sit on the page as one grid, the same on both hosts: no
// grouped card, so a single fact starts at the leading edge.
if (facts.isNotEmpty)
SliverToBoxAdapter(
child: FactsGrid(
key: const Key('run-detail-summary-facts'),
items: [
for (final row in facts)
FactsGridItem(
key: ValueKey('run-detail-summary-${_slug(row.label)}'),
label: row.label,
value: row.value,
monospace: row.monospace,
),
],
),
SliverToBoxAdapter(
child: LiveElapsedBuilder(
since: runningSince,
builder: (context, now) {
final shown = facts(now);
if (shown.isEmpty) return const SizedBox.shrink();
return FactsGrid(
key: const Key('run-detail-summary-facts'),
items: [
for (final row in shown)
FactsGridItem(
key: ValueKey('run-detail-summary-${_slug(row.label)}'),
label: row.label,
value: row.value,
monospace: row.monospace,
),
],
);
},
),
),
// Long blocks (the Diagnostic), Input and Output are sticky
// collapsibles: each title stays pinned while its content scrolls.
for (final row in rows)
@@ -5,6 +5,8 @@ import '../../../ui/layout/app_list_avatar.dart';
import '../../../ui/layout/app_list_row.dart';
import '../../../ui/status/outcome_palette.dart';
import '../../../ui/status/run_status_icon.dart';
import '../../../ui/text/live_elapsed_builder.dart';
import '../../pipelines/pipeline_format.dart' show formatDuration;
import '../domain/run_models.dart';
import 'run_detail_content.dart';
@@ -151,6 +153,15 @@ class RunTimelineRow extends StatelessWidget {
),
title: Text(visit.title),
time: visit.duration,
// A running visit's elapsed time ticks; only that label rebuilds.
timeWidget: visit.runningSince == null
? null
: LiveElapsedBuilder(
since: visit.runningSince,
builder: (context, now) => Text(
formatDuration(now.difference(visit.runningSince!).inSeconds),
),
),
subtitleLeading: _outcome(context),
subtitle: visit.target.isEmpty ? null : Text('→ ${visit.target}'),
);
+33 -17
View File
@@ -6,6 +6,7 @@ import '../../../ui/adaptive/host.dart';
import '../../../ui/layout/app_list_avatar.dart';
import '../../../ui/layout/app_list_row.dart';
import '../../../ui/status/run_status_icon.dart';
import '../../../ui/text/live_elapsed_builder.dart';
import '../../../ui/text/relative_time_label.dart';
import '../domain/run_deletion.dart';
import '../domain/run_models.dart';
@@ -62,7 +63,6 @@ class RunListRow extends StatelessWidget {
final identity = runIdentity(run['title'], run['name']);
final id = run['id'];
final title = identity.label.isEmpty ? 'Run $id' : identity.label;
final facts = runRowFacts(run, now);
// A run without its own title is named by its pipeline, so the pipeline
// line does not repeat it.
final pipeline = identity.pipeline?.trim();
@@ -78,22 +78,38 @@ class RunListRow extends StatelessWidget {
final bytes = runSizeBytes(run);
final size = bytes == null ? null : formatByteSize(bytes);
final createdAt = DateTime.tryParse('${run['created_at'] ?? ''}');
final subtitle = [
?pipelineLabel,
if (scheduled) 'Scheduled',
?facts.duration,
?facts.progress,
?size,
].join(' · ');
String subtitle(DateTime now) {
final facts = runRowFacts(run, now);
return [
?pipelineLabel,
if (scheduled) 'Scheduled',
?facts.duration,
?facts.progress,
?size,
].join(' · ');
}
// A narrow pane keeps the decision facts: the pipeline, and progress
// while executing (duration only when there is no pipeline to show).
final compactSubtitle = [
?pipelineLabel,
if (scheduled) 'Scheduled',
if (run['executing'] == true && facts.progress != null) facts.progress!,
if (pipelineLabel == null && facts.duration != null) facts.duration!,
?size,
].join(' · ');
String compactSubtitle(DateTime now) {
final facts = runRowFacts(run, now);
return [
?pipelineLabel,
if (scheduled) 'Scheduled',
if (run['executing'] == true && facts.progress != null) facts.progress!,
if (pipelineLabel == null && facts.duration != null) facts.duration!,
?size,
].join(' · ');
}
// An executing run's duration ticks; only its fact line rebuilds.
final runningSince = run['executing'] == true ? createdAt : null;
Widget line(String Function(DateTime now) text) => runningSince == null
? Text(text(now))
: LiveElapsedBuilder(
since: runningSince,
builder: (context, now) => Text(text(now)),
);
final state = runStateOf(run['status']);
return AppListRow(
key: ValueKey('run-row-$id'),
@@ -111,8 +127,8 @@ class RunListRow extends StatelessWidget {
timeWidget: createdAt == null
? null
: RelativeTimeLabel(instant: createdAt, now: now),
subtitle: Text(subtitle),
compactSubtitle: Text(compactSubtitle),
subtitle: line(subtitle),
compactSubtitle: line(compactSubtitle),
// Kept in a narrow list pane too, so every run's actions stay one tap
// away from the list.
menu:
@@ -283,7 +283,9 @@ class RunsController extends ChangeNotifier {
final selected = _selectedId;
if (selected != null &&
frame['run_id'] == selected &&
(folded.needsResync || runDetailNeedsFullSync(frame))) {
(folded.needsResync ||
runDetailNeedsFullSync(frame) ||
runDetailLacksStepStart(detail, frame))) {
_scheduleDetailRefresh(selected);
}
// A frame that changed neither the list nor the open detail shows
+1 -2
View File
@@ -330,8 +330,7 @@ class RunsList extends StatelessWidget {
id == controller.selectedRunId,
controller,
onSelected,
// An executing run's duration reads the clock, as before.
run['executing'] == true ? runRowFacts(run, now).duration : null,
// An executing run's duration ticks inside the row, not from here.
),
builder: (context) => _runRow(run, id, now, divider: divider),
);
+148
View File
@@ -0,0 +1,148 @@
import 'dart:async';
import 'package:flutter/widgets.dart';
/// One clock shared by every live elapsed-time label (a running run's or
/// stage's duration).
///
/// It runs a single timer, only while some label watches a start instant and
/// the app is visible, and wakes when the soonest watched duration next
/// changes its displayed text: every second under an hour (`3m 5s`), on the
/// minute under a day (`1h 2m`) and on the hour after that (`2d 3h`). Labels
/// rebuild themselves on a tick; nothing else in the tree does.
class ElapsedClock with WidgetsBindingObserver {
/// [now] reads the time; tests pass a fake clock.
ElapsedClock({DateTime Function()? now}) : _read = now ?? DateTime.now;
/// The clock the app's labels share.
static final ElapsedClock shared = ElapsedClock();
final DateTime Function() _read;
final Map<Object, ({DateTime since, VoidCallback onTick})> _watchers = {};
Timer? _timer;
bool _observing = false;
bool _hidden = false;
/// The boundary the last tick was due at. The next tick is scheduled from
/// it when the wall clock lags the timer (a test's fake timers), so a tick
/// always moves on to the next boundary rather than re-arming for the same
/// one.
DateTime? _reached;
DateTime get now => _read();
/// Whether a tick is scheduled (a label watches and the app is visible).
@visibleForTesting
bool get ticking => _timer != null;
/// Calls [onTick] whenever a duration measured from [since] may have
/// changed its text, until [unwatch] with the same [key].
void watch(Object key, DateTime since, VoidCallback onTick) {
_watchers[key] = (since: since, onTick: onTick);
if (!_observing) {
_hidden = switch (WidgetsBinding.instance.lifecycleState) {
AppLifecycleState.hidden ||
AppLifecycleState.paused ||
AppLifecycleState.detached => true,
_ => false,
};
WidgetsBinding.instance.addObserver(this);
_observing = true;
}
_schedule();
}
void unwatch(Object key) {
if (_watchers.remove(key) == null) return;
if (_watchers.isNotEmpty) {
_schedule();
return;
}
_stop();
_reached = null;
if (_observing) {
WidgetsBinding.instance.removeObserver(this);
_observing = false;
}
}
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
if (state == AppLifecycleState.resumed) {
_hidden = false;
_notify();
_schedule();
} else if (state == AppLifecycleState.hidden ||
// Not inactive: a desktop window that lost focus is still visible.
state == AppLifecycleState.paused ||
state == AppLifecycleState.detached) {
_hidden = true;
_stop();
}
}
void _schedule() {
_stop();
if (_hidden || _watchers.isEmpty) return;
final wall = _read();
final reached = _reached;
final from = reached != null && reached.isAfter(wall) ? reached : wall;
Duration? delay;
for (final watcher in _watchers.values) {
final next = elapsedTextChangesIn(from.difference(watcher.since));
if (delay == null || next < delay) delay = next;
}
final due = from.add(delay!);
_timer = Timer(delay, () {
_timer = null;
_reached = due;
_notify();
_schedule();
});
}
void _notify() {
for (final watcher in [..._watchers.values]) {
watcher.onTick();
}
}
void _stop() {
_timer?.cancel();
_timer = null;
}
}
/// How long until an elapsed duration shown at `formatDuration` precision
/// (seconds under an hour, minutes under a day, then hours) shows new text.
/// A negative elapsed (clock skew) reads `0s` until it reaches one second.
@visibleForTesting
Duration elapsedTextChangesIn(Duration elapsed) {
if (elapsed.isNegative) return -elapsed + const Duration(seconds: 1);
final unit = elapsed < const Duration(hours: 1)
? const Duration(seconds: 1)
: elapsed < const Duration(days: 1)
? const Duration(minutes: 1)
: const Duration(hours: 1);
final into = elapsed.inMicroseconds % unit.inMicroseconds;
return Duration(microseconds: unit.inMicroseconds - into);
}
/// Supplies the [ElapsedClock] below it; [ElapsedClock.shared] without one.
class ElapsedClockScope extends InheritedWidget {
const ElapsedClockScope({
super.key,
required this.clock,
required super.child,
});
final ElapsedClock clock;
static ElapsedClock of(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<ElapsedClockScope>()?.clock ??
ElapsedClock.shared;
@override
bool updateShouldNotify(ElapsedClockScope oldWidget) =>
clock != oldWidget.clock;
}
+83
View File
@@ -0,0 +1,83 @@
import 'package:flutter/widgets.dart';
import 'elapsed_clock.dart';
/// Builds a running item's elapsed-time text from the [ElapsedClock], and
/// rebuilds only itself as that duration advances.
///
/// With a null [since] (nothing running) it builds once from the clock's time
/// and watches nothing, so no timer runs. While its tickers are muted (an
/// offstage tab or a covered route) it stops watching and catches up when
/// shown again.
class LiveElapsedBuilder extends StatefulWidget {
const LiveElapsedBuilder({
super.key,
required this.since,
required this.builder,
});
/// When the running item started; null when it is not running.
final DateTime? since;
/// Builds the text for the clock's current time.
final Widget Function(BuildContext context, DateTime now) builder;
@override
State<LiveElapsedBuilder> createState() => _LiveElapsedBuilderState();
}
class _LiveElapsedBuilderState extends State<LiveElapsedBuilder> {
ElapsedClock? _clock;
bool _shown = true;
bool _watching = false;
@override
void didChangeDependencies() {
super.didChangeDependencies();
final clock = ElapsedClockScope.of(context);
if (clock != _clock) {
_unwatch();
_clock = clock;
}
_shown = TickerMode.valuesOf(context).enabled;
_sync();
}
@override
void didUpdateWidget(LiveElapsedBuilder oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.since != widget.since) {
_unwatch();
_sync();
}
}
void _sync() {
final since = widget.since;
if (since == null || !_shown) {
_unwatch();
} else if (!_watching) {
_clock!.watch(this, since, _tick);
_watching = true;
}
}
void _unwatch() {
if (!_watching) return;
_clock?.unwatch(this);
_watching = false;
}
void _tick() {
if (mounted) setState(() {});
}
@override
Widget build(BuildContext context) => widget.builder(context, _clock!.now);
@override
void dispose() {
_unwatch();
super.dispose();
}
}
+33
View File
@@ -0,0 +1,33 @@
# Live run durations
Running runs and stages now show durations that update on their own, without a refresh.
- `lib/ui/text/elapsed_clock.dart` has one shared `ElapsedClock`. It runs a single
timer only while some label is watching, and only while the app is visible. The
timer wakes when the shortest watched duration would next change its text: every
second under an hour (`3m 5s`), every minute under a day (`1h 2m`), then every hour.
`ElapsedClockScope` lets tests inject a fake clock (`ElapsedClock(now: ...)`).
- `lib/ui/text/live_elapsed_builder.dart` rebuilds only its own subtree. With a null
`since` it watches nothing. It also stops watching while muted (an offstage tab or a
covered route) and catches up when shown again.
- Runs list: an executing row's fact lines tick (`run_list_row.dart`). The list's memo
no longer keys on the clock.
- Run detail: an executing run's Summary shows a ticking Duration fact
(`detailSummaryRows(run, now:)`). A running Timeline visit's time ticks too
(`DetailVisit.runningSince`).
- Status and finish times already arrive through `run_event` frames. The terminal
frame carries `finished_at`, so a row changes from a ticking duration to the
recorded one without a refresh. A step delta carries no `started_at`, so a stage
start re-reads the open detail (`runDetailLacksStepStart`).
- Bench budget (`test/perf/background_work_bench_test.dart`): with 20 visible running
rows there are 2 active timers (minute labels plus elapsed clock) and 61 timers
per minute. Before this change it was 1 timer, because running rows did not tick.
Evidence: `test/ui/text/elapsed_clock_test.dart` and
`test/features/runs/ui/run_live_duration_test.dart` use fake clocks. The browser
capture used `?running=1` on the full-app fixture, at `/runs` 880x1000. Seven
seconds apart, the row read `release-train · 3m 53s` and then
`release-train · 4m 0s`.
Not covered: the visit pane's Duration fact is still the recorded one. A `waiting`
run does not tick, which matches the list's existing rule.
@@ -0,0 +1,215 @@
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/run_detail_content.dart';
import 'package:pipelines_app/features/runs/ui/run_detail_tab_bodies.dart';
import 'package:pipelines_app/features/runs/ui/run_detail_timeline.dart';
import 'package:pipelines_app/features/runs/ui/run_list_row.dart';
import 'package:pipelines_app/features/runs/ui/runs_controller.dart';
import 'package:pipelines_app/ui/text/elapsed_clock.dart';
final _start = DateTime.utc(2026, 11, 4, 12);
final _running = <String, dynamic>{
'id': 9,
'title': 'Nightly build',
'name': 'release',
'status': 'running',
'executing': true,
'created_at': '2026-11-04T12:00:00Z',
'finished_at': '',
'current_stage': 'build',
};
final _succeeded = <String, dynamic>{
..._running,
'status': 'succeeded',
'executing': false,
'finished_at': '2026-11-04T12:02:05Z',
};
/// A fake wall clock advanced together with the test's fake timers.
class _Time {
_Time(this.value);
DateTime value;
late final clock = ElapsedClock(now: () => value);
Future<void> advance(WidgetTester tester, Duration by) async {
value = value.add(by);
await tester.pump(by);
}
}
Widget _host(_Time time, Widget child) => MaterialApp(
home: ElapsedClockScope(
clock: time.clock,
child: Scaffold(body: child),
),
);
Finder _textContaining(String text) => find.textContaining(text);
class _Gateway implements ApiGateway {
final framesController = StreamController<JsonMap>.broadcast();
final detailRequests = <Completer<JsonMap>>[];
@override
Stream<JsonMap> get frames => framesController.stream;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
final request = Completer<JsonMap>();
if (type == 'get_run') detailRequests.add(request);
return request.future;
}
}
void main() {
testWidgets('a running row ticks and stops once the run completes', (
tester,
) async {
final time = _Time(_start.add(const Duration(seconds: 45)));
Widget row(JsonMap run) =>
_host(time, RunListRow(run: run, now: time.value));
await tester.pumpWidget(row(_running));
expect(_textContaining('45s'), findsOneWidget);
await time.advance(tester, const Duration(seconds: 1));
expect(_textContaining('46s'), findsOneWidget);
await time.advance(tester, const Duration(seconds: 14));
expect(_textContaining('1m 0s'), findsOneWidget);
expect(time.clock.ticking, isTrue);
// The terminal frame's row: the recorded duration, no timer.
await tester.pumpWidget(row(_succeeded));
expect(_textContaining('2m 5s'), findsOneWidget);
expect(time.clock.ticking, isFalse);
});
testWidgets('no timer runs when no row is running', (tester) async {
final time = _Time(_start.add(const Duration(minutes: 5)));
await tester.pumpWidget(
_host(
time,
Column(
children: [
RunListRow(run: _succeeded, now: time.value),
RunListRow(
run: {..._running, 'status': 'waiting', 'executing': false},
now: time.value,
),
],
),
),
);
expect(time.clock.ticking, isFalse);
});
testWidgets('the Summary Duration of a running run ticks', (tester) async {
final time = _Time(_start.add(const Duration(seconds: 59)));
await tester.pumpWidget(
_host(
time,
Builder(
builder: (context) => runDetailSummaryTab(
context: context,
run: _running,
cupertino: false,
copying: false,
copyStatus: null,
onCopy: () {},
),
),
),
);
expect(find.text('59s'), findsOneWidget);
await time.advance(tester, const Duration(seconds: 1));
expect(find.text('1m 0s'), findsOneWidget);
await tester.pumpWidget(const SizedBox());
expect(time.clock.ticking, isFalse);
});
testWidgets('a running stage row ticks; finished rows keep their time', (
tester,
) async {
final time = _Time(_start.add(const Duration(minutes: 3, seconds: 4)));
final steps = [
{
'stage': 'plan',
'sequence': 1,
'status': 'completed',
'outcome': 'success',
'started_at': '2026-11-04T11:58:00Z',
'finished_at': '2026-11-04T12:00:00Z',
},
{
'stage': 'build',
'sequence': 2,
'status': 'running',
'started_at': '2026-11-04T12:00:00Z',
},
];
await tester.pumpWidget(
_host(
time,
RunTimelineList(
visits: detailTimeline(steps),
cupertino: false,
onSelected: (_) {},
),
),
);
expect(find.text('2m 0s'), findsOneWidget);
expect(find.text('3m 4s'), findsOneWidget);
await time.advance(tester, const Duration(seconds: 1));
expect(find.text('3m 5s'), findsOneWidget);
expect(find.text('2m 0s'), findsOneWidget);
await tester.pumpWidget(const SizedBox());
expect(time.clock.ticking, isFalse);
});
test('a terminal frame finishes the row without a list refresh', () async {
final gateway = _Gateway();
final controller = RunsController(RunsRepository(gateway))
..runs = [_running]
..listen(gateway.frames);
addTearDown(() {
controller.dispose();
gateway.framesController.close();
});
gateway.framesController.add({
'type': 'run_event',
'run_id': 9,
'status': 'succeeded',
'finished_at': '2026-11-04T12:02:05Z',
});
await Future<void>.delayed(Duration.zero);
final row = controller.runs.single;
expect(row['status'], 'succeeded');
expect(row['executing'], isFalse);
expect(row['finished_at'], '2026-11-04T12:02:05Z');
});
test('a stage start re-reads the open detail for its start time', () async {
final gateway = _Gateway();
final controller = RunsController(RunsRepository(gateway));
addTearDown(() {
controller.dispose();
gateway.framesController.close();
});
final select = controller.select(9);
gateway.detailRequests.single.complete({
'run_detail': {..._running, 'steps': <Object>[]},
});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 9,
'status': 'running',
'step': {'sequence': 1, 'stage': 'build', 'status': 'running'},
});
await Future<void>.delayed(const Duration(milliseconds: 200));
expect(gateway.detailRequests, hasLength(2));
});
}
@@ -163,7 +163,10 @@ void main() {
'totalRebuildsPerMinute=${rebuilds.total} '
'timersScheduledPerMinute=$perMinute',
);
expect(active, lessThanOrEqualTo(1));
// 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);
});
+111
View File
@@ -0,0 +1,111 @@
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/ui/text/elapsed_clock.dart';
import 'package:pipelines_app/ui/text/live_elapsed_builder.dart';
/// A fake wall clock the test advances together with the fake timers.
class _Time {
_Time(this.value);
DateTime value;
Future<void> advance(WidgetTester tester, Duration by) async {
value = value.add(by);
await tester.pump(by);
}
}
void main() {
test('wakes when the displayed precision next changes', () {
expect(elapsedTextChangesIn(Duration.zero), const Duration(seconds: 1));
expect(
elapsedTextChangesIn(const Duration(seconds: 59, milliseconds: 400)),
const Duration(milliseconds: 600),
);
// `1h 2m` shows minutes, `2d 3h` hours.
expect(
elapsedTextChangesIn(const Duration(hours: 1, minutes: 2, seconds: 15)),
const Duration(seconds: 45),
);
expect(
elapsedTextChangesIn(const Duration(days: 2, minutes: 30)),
const Duration(minutes: 30),
);
// Clock skew reads 0s until a second has passed.
expect(
elapsedTextChangesIn(const Duration(seconds: -2)),
const Duration(seconds: 3),
);
});
testWidgets('a live label ticks, stops when no longer running and on '
'dispose', (tester) async {
final start = DateTime.utc(2026, 11, 4, 12);
final time = _Time(start.add(const Duration(seconds: 5)));
final clock = ElapsedClock(now: () => time.value);
var builds = 0;
Widget app(DateTime? since) => Directionality(
textDirection: TextDirection.ltr,
child: ElapsedClockScope(
clock: clock,
child: LiveElapsedBuilder(
since: since,
builder: (context, now) {
builds += 1;
return Text('${now.difference(start).inSeconds}s');
},
),
),
);
await tester.pumpWidget(app(start));
expect(find.text('5s'), findsOneWidget);
expect(clock.ticking, isTrue);
await time.advance(tester, const Duration(seconds: 1));
expect(find.text('6s'), findsOneWidget);
await time.advance(tester, const Duration(seconds: 1));
expect(find.text('7s'), findsOneWidget);
// Finished: no longer watched, so the timer stops.
await tester.pumpWidget(app(null));
expect(clock.ticking, isFalse);
final settled = builds;
await time.advance(tester, const Duration(seconds: 5));
expect(builds, settled);
await tester.pumpWidget(app(start));
expect(clock.ticking, isTrue);
await tester.pumpWidget(const SizedBox());
expect(clock.ticking, isFalse);
});
testWidgets('a muted label stops ticking and catches up when shown', (
tester,
) async {
final start = DateTime.utc(2026, 11, 4, 12);
final time = _Time(start);
final clock = ElapsedClock(now: () => time.value);
Widget app({required bool shown}) => Directionality(
textDirection: TextDirection.ltr,
child: ElapsedClockScope(
clock: clock,
child: TickerMode(
enabled: shown,
child: LiveElapsedBuilder(
since: start,
builder: (context, now) =>
Text('${now.difference(start).inSeconds}s'),
),
),
),
);
await tester.pumpWidget(app(shown: true));
expect(clock.ticking, isTrue);
await tester.pumpWidget(app(shown: false));
expect(clock.ticking, isFalse);
await time.advance(tester, const Duration(seconds: 30));
await tester.pumpWidget(app(shown: true));
expect(find.text('30s'), findsOneWidget);
expect(clock.ticking, isTrue);
await tester.pumpWidget(const SizedBox());
});
}
@@ -123,6 +123,10 @@ JsonMap _probeChanges(List<String> paths) => {
int _fillerRunCount = 0;
int _fillerStepCount = 0;
/// `?running=1`: run 8 executes, started 3m 50s before the page loaded, so a
/// capture shows its duration ticking. Absent by default.
DateTime? _runningSince;
List<JsonMap> _fillerSteps() => [
for (var i = 0; i < _fillerStepCount; i++)
{
@@ -151,6 +155,19 @@ List<JsonMap> _fillerRuns() => [
];
List<JsonMap> probeRuns() => [
if (_runningSince != null)
{
'id': 8,
'title': 'Live deploy run',
'name': 'release-train',
'status': 'running',
'executing': true,
'current_stage': 'deploy',
'completed_steps': 2,
'created_at': _runningSince!.toUtc().toIso8601String(),
'finished_at': '',
'pipeline_id': 24,
},
{
'id': 7,
'title': 'Release train run',
@@ -583,6 +600,7 @@ class _FixtureSink implements WebSocketSink {
/// `?route=/runs/7/stage/build%3Fvisit%3D1` opens that app location;
/// `?runs=200` / `?steps=60` append filler runs / run-7 steps for scroll
/// performance captures;
/// `?running=1` adds an executing run 8 whose duration ticks;
/// `?q=release` types that query into Search once its field is shown;
/// `?platform=cupertino` renders the Cupertino host (`material`, the
/// default, renders Material as browsers do);
@@ -606,6 +624,11 @@ void main() {
configurePerfFixture(params);
_fillerRunCount = int.tryParse(params['runs'] ?? '') ?? 0;
_fillerStepCount = int.tryParse(params['steps'] ?? '') ?? 0;
if (params['running'] == '1') {
_runningSince = DateTime.now().subtract(
const Duration(minutes: 3, seconds: 50),
);
}
final cupertino = params['platform'] == 'cupertino';
final route = params['route'];
final opensRoute = route != null && route.startsWith('/');