feat(app): show the live Needs-you bell over the Runs list rows
This commit is contained in:
+1
-1
@@ -52,7 +52,7 @@ or scratch servers only, never real operator sessions/runs/workflows.
|
||||
| Saved schedule list | Source | pipeline entry and route registration, exact timer provenance vocabulary |
|
||||
| Schedule editor | Preview: pipeline Summary section creates/edits/pauses/deletes with the lossless draft and revision guard; conflict keeps the draft and shows the server words | Schedule-this-run seeding, schedules list entry/route |
|
||||
| Search | Preview: shell entry, /search route, focused field, restore on close | result target routing for pipeline/version/field/visit/artifact hits |
|
||||
| Needs you | Source model + native bell/sheet; wiring90 | in-app count from list rows, dismiss persistence and live transitions |
|
||||
| Needs you | Preview: runs-list bell/count, native sheet, open/dismiss/clear persistence, live fold and reconnect reseed | notification transitions/permission, authenticated preview smoke |
|
||||
| Notifications | Missing | explicit permission/rationale, secure/unsupported/denied states, transition-only dedupe, background question notices |
|
||||
| Mobile replacement build | Scaffold only | Android build at end; all source portable to iOS, isolated IDs; device/OS behavior clearly separate |
|
||||
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import '../../../core/api_gateway.dart';
|
||||
import '../../runs/domain/run_events.dart';
|
||||
import '../domain/attention_models.dart';
|
||||
import '../domain/attention_transitions.dart';
|
||||
import 'attention_store.dart';
|
||||
|
||||
/// The live `Needs you` state behind the Runs-list bell.
|
||||
///
|
||||
/// Entries are derived from the same `list_runs` rows the Runs destination
|
||||
/// already holds: no poll and no extra request is made here. Pushed
|
||||
/// `run_event` frames are folded with the runs feature's own [foldRunEvent], so
|
||||
/// a run that becomes failed or waiting while the screen is open appears without
|
||||
/// a reload, exactly as the browser's attention surface does.
|
||||
///
|
||||
/// Dismissals are kept in memory for immediate feedback and written through
|
||||
/// [AttentionStore] without blocking the caller. A failed read or write leaves
|
||||
/// the in-memory set in force for this session; neither direction can throw into
|
||||
/// the UI.
|
||||
class AttentionController extends ChangeNotifier {
|
||||
AttentionController({required this.store, DateTime Function()? now})
|
||||
: _now = now ?? DateTime.now;
|
||||
|
||||
final AttentionStore store;
|
||||
final DateTime Function() _now;
|
||||
final AttentionTransitionDetector _detector = AttentionTransitionDetector();
|
||||
final List<AttentionTransition> _transitions = [];
|
||||
|
||||
List<JsonMap> _rows = const [];
|
||||
Set<String> _dismissed = <String>{};
|
||||
bool _loaded = false;
|
||||
bool _dirty = false;
|
||||
bool _disposed = false;
|
||||
|
||||
/// The summaries the surface currently draws from.
|
||||
List<JsonMap> get rows => _rows;
|
||||
|
||||
/// The identities the operator has dismissed in this session or storage.
|
||||
Set<String> get dismissed => {..._dismissed};
|
||||
|
||||
/// True once the persisted set has been read (successfully or not).
|
||||
bool get loaded => _loaded;
|
||||
|
||||
/// Transition facts raised by pushed frames, kept for notification wiring.
|
||||
List<AttentionTransition> get transitions =>
|
||||
List<AttentionTransition>.unmodifiable(_transitions);
|
||||
|
||||
/// Today's ordered rows, minus explicitly dismissed identities.
|
||||
///
|
||||
/// The local-day cutoff is the model's [startOfLocalDay]: yesterday's failures
|
||||
/// are history, not a badge that follows every device for ever. A caller that
|
||||
/// needs a different window should use [entriesSince] rather than a second
|
||||
/// ordering implementation.
|
||||
List<AttentionEntry> get entries =>
|
||||
entriesSince(startOfLocalDay(now: _now()));
|
||||
|
||||
/// The ordered rows within an explicit [since] window.
|
||||
List<AttentionEntry> entriesSince(DateTime? since) =>
|
||||
attentionEntries(_rows, dismissed: _dismissed, since: since);
|
||||
|
||||
/// Reads the persisted dismissals once. Unreadable storage means "none".
|
||||
Future<void> load() async {
|
||||
Set<String> stored;
|
||||
try {
|
||||
stored = decodeAttentionDismissals(await store.read());
|
||||
} catch (_) {
|
||||
stored = <String>{};
|
||||
}
|
||||
if (_disposed) return;
|
||||
_loaded = true;
|
||||
// A dismissal made while the read was in flight must not be reverted by the
|
||||
// older stored value; the in-memory set is the operator's latest intent.
|
||||
if (!_dirty) _dismissed = stored;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Replaces the drawn rows with an authoritative read.
|
||||
///
|
||||
/// The transition detector is seeded rather than observed, so the initial list
|
||||
/// and a reconnect cannot announce work that was already there. With
|
||||
/// [reconnect] the status baseline is dropped first, while emitted keys are
|
||||
/// retained by the model so the gap cannot re-notify.
|
||||
void seedRows(Iterable<JsonMap> rows, {bool reconnect = false}) {
|
||||
if (_disposed) return;
|
||||
_rows = List<JsonMap>.unmodifiable(rows);
|
||||
if (reconnect) {
|
||||
_detector.reseed(_rows);
|
||||
} else {
|
||||
_detector.seed(_rows);
|
||||
}
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/// Called when the shared socket drops, before the next [seedRows].
|
||||
void resetForReconnect() {
|
||||
if (_disposed) return;
|
||||
_detector.resetForReconnect();
|
||||
}
|
||||
|
||||
/// Folds one pushed run summary into the drawn entries.
|
||||
///
|
||||
/// A frame that cannot build a complete summary asks the Runs controller for
|
||||
/// its usual resync; this surface never issues a request of its own. The
|
||||
/// transition (if any) is recorded for the notification wiring but a dismissed
|
||||
/// identity never emits.
|
||||
void observeFrame(JsonMap frame) {
|
||||
if (_disposed) return;
|
||||
final transition = _detector.observe(frame, dismissed: _dismissed);
|
||||
if (transition != null) _transitions.add(transition);
|
||||
final folded = foldRunEvent(_rows, frame);
|
||||
final changed = !folded.needsResync && !identical(folded.runs, _rows);
|
||||
if (changed) {
|
||||
_rows = List<JsonMap>.unmodifiable(
|
||||
_withAttentionText(folded.runs, frame),
|
||||
);
|
||||
}
|
||||
if (changed || transition != null) notifyListeners();
|
||||
}
|
||||
|
||||
/// The runs fold deliberately carries only lifecycle fields, but the attention
|
||||
/// row's wording comes from `title`/`name`/`diagnostic`. Keep those summary
|
||||
/// fields from the same push so a failure announces its real reason without
|
||||
/// waiting for the next list read. Only non-blank pushed values win; the source
|
||||
/// or other unknown fields are left untouched.
|
||||
List<JsonMap> _withAttentionText(List<JsonMap> rows, JsonMap frame) {
|
||||
final id = frame['run_id'];
|
||||
final index = rows.indexWhere((row) => row['id'] == id);
|
||||
if (index < 0) return rows;
|
||||
final current = rows[index];
|
||||
final merged = <String, dynamic>{...current};
|
||||
var changed = false;
|
||||
for (final key in const ['title', 'name', 'diagnostic']) {
|
||||
final value = frame[key];
|
||||
if ('${value ?? ''}'.trim().isEmpty || value == current[key]) continue;
|
||||
merged[key] = value;
|
||||
changed = true;
|
||||
}
|
||||
if (!changed) return rows;
|
||||
final next = [...rows];
|
||||
next[index] = merged;
|
||||
return next;
|
||||
}
|
||||
|
||||
/// Dismisses exactly one identity and persists the new set.
|
||||
///
|
||||
/// The in-memory set and the bell update before the store is touched, so a
|
||||
/// slow or failed write never blocks the sheet. The returned future reports
|
||||
/// whether the write succeeded; callers that do not need it may ignore it.
|
||||
Future<bool> dismiss(AttentionEntry entry) =>
|
||||
_commit(attentionDismiss(_dismissed, entry.key));
|
||||
|
||||
/// Applies only the identities captured when the sheet opened.
|
||||
Future<bool> clearAll(Iterable<AttentionEntry> snapshot) =>
|
||||
_commit(attentionDismissAll(_dismissed, snapshot));
|
||||
|
||||
Future<bool> _commit(Set<String> next) async {
|
||||
final unchanged =
|
||||
next.length == _dismissed.length && next.containsAll(_dismissed);
|
||||
if (unchanged) return true;
|
||||
_dismissed = next;
|
||||
_dirty = true;
|
||||
notifyListeners();
|
||||
if (_disposed) return false;
|
||||
try {
|
||||
return await store.write(encodeAttentionDismissals(_dismissed));
|
||||
} catch (_) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_disposed = true;
|
||||
super.dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
import '../domain/attention_models.dart';
|
||||
|
||||
/// The persistence seam for the `Needs you` dismissal identities.
|
||||
///
|
||||
/// The controller only ever hands over the exact string produced by
|
||||
/// [encodeAttentionDismissals], so a store cannot invent a different identity
|
||||
/// format. Both directions are allowed to fail: a caller treats a null read as
|
||||
/// "nothing dismissed yet" and a false write as "this session only".
|
||||
abstract interface class AttentionStore {
|
||||
Future<String?> read();
|
||||
|
||||
Future<bool> write(String value);
|
||||
}
|
||||
|
||||
/// `shared_preferences` storage under the attention model's own key.
|
||||
///
|
||||
/// Reads and writes are total: an unavailable plugin, a disabled store or a full
|
||||
/// disk returns null/false instead of throwing into the caller's frame. Only the
|
||||
/// documented [attentionStorageKey] is touched, never the legacy web key.
|
||||
class SharedPreferencesAttentionStore implements AttentionStore {
|
||||
const SharedPreferencesAttentionStore();
|
||||
|
||||
Future<SharedPreferences?> _preferences() async {
|
||||
try {
|
||||
return await SharedPreferences.getInstance();
|
||||
} catch (_) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<String?> read() async {
|
||||
final preferences = await _preferences();
|
||||
if (preferences == null) return null;
|
||||
try {
|
||||
return preferences.getString(attentionStorageKey);
|
||||
} catch (_) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> write(String value) async {
|
||||
final preferences = await _preferences();
|
||||
if (preferences == null) return false;
|
||||
try {
|
||||
return await preferences.setString(attentionStorageKey, value);
|
||||
} catch (_) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An in-memory store for tests and isolated fixtures.
|
||||
///
|
||||
/// It never touches the platform store, so a probe or widget test cannot mutate
|
||||
/// a real operator's persisted dismissals. [failReads] and [failWrites] reproduce
|
||||
/// an unavailable store without throwing.
|
||||
class MemoryAttentionStore implements AttentionStore {
|
||||
MemoryAttentionStore({this.stored});
|
||||
|
||||
String? stored;
|
||||
bool failReads = false;
|
||||
bool failWrites = false;
|
||||
int writes = 0;
|
||||
|
||||
@override
|
||||
Future<String?> read() async {
|
||||
if (failReads) throw StateError('attention store unavailable');
|
||||
return stored;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> write(String value) async {
|
||||
writes++;
|
||||
if (failWrites) throw StateError('attention store is read-only');
|
||||
stored = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/widgets.dart';
|
||||
|
||||
import '../../../core/api_gateway.dart';
|
||||
import '../domain/attention_models.dart';
|
||||
import '../runtime/attention_controller.dart';
|
||||
import '../runtime/attention_store.dart';
|
||||
import 'needs_you_bell.dart';
|
||||
|
||||
/// The `Needs you` bell as it appears in the Runs list heading.
|
||||
///
|
||||
/// It owns the live attention state for this destination: [rows] are the
|
||||
/// already-loaded `list_runs` summaries and [frames] is the shared gateway's
|
||||
/// unsolicited stream, so it never polls or issues an attention request. The
|
||||
/// bell has no built-in host choice; the ambient app host (or [cupertino] in a
|
||||
/// fixture) selects the native Material or Cupertino action and sheet.
|
||||
class NeedsYouRunsHeading extends StatefulWidget {
|
||||
const NeedsYouRunsHeading({
|
||||
super.key,
|
||||
required this.rows,
|
||||
required this.frames,
|
||||
required this.onOpen,
|
||||
this.syncToken = 0,
|
||||
this.store = const SharedPreferencesAttentionStore(),
|
||||
this.now,
|
||||
this.cupertino,
|
||||
});
|
||||
|
||||
/// The run summaries the Runs destination already holds.
|
||||
final List<JsonMap> rows;
|
||||
|
||||
/// The shared gateway's frames; only `run_event` envelopes are folded.
|
||||
final Stream<JsonMap> frames;
|
||||
|
||||
/// Opens an entry's run. A Failed entry is dismissed by the bell first.
|
||||
final ValueChanged<AttentionEntry> onOpen;
|
||||
|
||||
/// Advances when the shared socket is replaced. The detector rebaselines
|
||||
/// without replaying a transition that happened during the gap.
|
||||
final int syncToken;
|
||||
|
||||
final AttentionStore store;
|
||||
|
||||
/// Injected clock for deterministic local-day windows.
|
||||
final DateTime Function()? now;
|
||||
|
||||
/// Forces the native host in tests and fixtures.
|
||||
final bool? cupertino;
|
||||
|
||||
@override
|
||||
State<NeedsYouRunsHeading> createState() => _NeedsYouRunsHeadingState();
|
||||
}
|
||||
|
||||
class _NeedsYouRunsHeadingState extends State<NeedsYouRunsHeading> {
|
||||
late final AttentionController _attention = AttentionController(
|
||||
store: widget.store,
|
||||
now: widget.now,
|
||||
);
|
||||
StreamSubscription<JsonMap>? _frames;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_attention.seedRows(widget.rows);
|
||||
unawaited(_attention.load());
|
||||
_listen();
|
||||
}
|
||||
|
||||
void _listen() {
|
||||
_frames = widget.frames
|
||||
.where((frame) => frame['type'] == 'run_event')
|
||||
.listen(_attention.observeFrame);
|
||||
}
|
||||
|
||||
@override
|
||||
void didUpdateWidget(covariant NeedsYouRunsHeading oldWidget) {
|
||||
super.didUpdateWidget(oldWidget);
|
||||
if (!identical(oldWidget.frames, widget.frames)) {
|
||||
unawaited(_frames?.cancel());
|
||||
_frames = null;
|
||||
_listen();
|
||||
}
|
||||
if (oldWidget.syncToken != widget.syncToken) {
|
||||
_attention.resetForReconnect();
|
||||
_attention.seedRows(widget.rows, reconnect: true);
|
||||
return;
|
||||
}
|
||||
if (!identical(oldWidget.rows, widget.rows)) {
|
||||
_attention.seedRows(widget.rows);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
unawaited(_frames?.cancel());
|
||||
_attention.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return AnimatedBuilder(
|
||||
animation: _attention,
|
||||
builder: (context, _) => NeedsYouBell(
|
||||
entries: _attention.entries,
|
||||
cupertino: widget.cupertino,
|
||||
onOpen: widget.onOpen,
|
||||
onDismiss: (entry) {
|
||||
unawaited(_attention.dismiss(entry));
|
||||
},
|
||||
onClearAll: (snapshot) {
|
||||
unawaited(_attention.clearAll(snapshot));
|
||||
},
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
import 'package:flutter/widgets.dart';
|
||||
|
||||
import '../../core/api_gateway.dart';
|
||||
import '../attention/runtime/attention_store.dart';
|
||||
import 'data/runs_repository.dart';
|
||||
import 'ui/run_detail_view.dart';
|
||||
import 'ui/runs_controller.dart';
|
||||
@@ -20,6 +21,8 @@ class RunsScreen extends StatefulWidget {
|
||||
this.syncToken = 0,
|
||||
this.onRunSelected,
|
||||
this.onBack,
|
||||
this.attentionStore = const SharedPreferencesAttentionStore(),
|
||||
this.attentionNow,
|
||||
});
|
||||
|
||||
final ApiGateway gateway;
|
||||
@@ -34,6 +37,11 @@ class RunsScreen extends StatefulWidget {
|
||||
final ValueChanged<int>? onRunSelected;
|
||||
final VoidCallback? onBack;
|
||||
|
||||
/// Persisted attention dismissals and the clock for its local-day window.
|
||||
/// The app uses SharedPreferences; tests and fixtures inject a memory store.
|
||||
final AttentionStore attentionStore;
|
||||
final DateTime Function()? attentionNow;
|
||||
|
||||
@override
|
||||
State<RunsScreen> createState() => _RunsScreenState();
|
||||
}
|
||||
@@ -103,7 +111,13 @@ class _RunsScreenState extends State<RunsScreen> {
|
||||
animation: controller,
|
||||
builder: (context, _) => Offstage(
|
||||
offstage: selected,
|
||||
child: RunsList(controller: controller, onSelected: _select),
|
||||
child: RunsList(
|
||||
controller: controller,
|
||||
onSelected: _select,
|
||||
syncToken: widget.syncToken,
|
||||
attentionStore: widget.attentionStore,
|
||||
attentionNow: widget.attentionNow,
|
||||
),
|
||||
),
|
||||
),
|
||||
if (selected)
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../../../ui/adaptive/host.dart';
|
||||
import 'runs_controller.dart';
|
||||
|
||||
/// The runs list's native sort/schedule/status controls.
|
||||
///
|
||||
/// On Cupertino the controls stay in one horizontally scrollable strip: a phone
|
||||
/// at a doubled text scale cannot stack seven buttons above the list without
|
||||
/// crushing it, and the browser's narrow toolbar is likewise one row. Material
|
||||
/// keeps its native dropdowns and filter chips.
|
||||
class RunsFilters extends StatelessWidget {
|
||||
const RunsFilters({super.key, required this.controller});
|
||||
|
||||
final RunsController controller;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) =>
|
||||
usesCupertinoHost(context) ? _cupertino(context) : _material(context);
|
||||
|
||||
Widget _cupertino(BuildContext context) => SingleChildScrollView(
|
||||
scrollDirection: Axis.horizontal,
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
|
||||
child: Row(
|
||||
children: [
|
||||
CupertinoButton(
|
||||
onPressed: () => _choose(
|
||||
context,
|
||||
'Sort runs',
|
||||
_sorts,
|
||||
controller.sort,
|
||||
controller.setSort,
|
||||
),
|
||||
child: Text('Sort: ${_sortLabel(controller.sort)}'),
|
||||
),
|
||||
const SizedBox(width: 8),
|
||||
CupertinoButton(
|
||||
onPressed: () => _choose(
|
||||
context,
|
||||
'Schedule',
|
||||
_schedules,
|
||||
controller.scheduled,
|
||||
controller.setScheduled,
|
||||
),
|
||||
child: Text('Schedule: ${_scheduleLabel(controller.scheduled)}'),
|
||||
),
|
||||
for (final status in _statuses) ...[
|
||||
const SizedBox(width: 8),
|
||||
CupertinoButton(
|
||||
onPressed: () => controller.setStatus(status),
|
||||
child: Text(
|
||||
'${controller.statuses.contains(status) ? '✓ ' : ''}${_title(status)}',
|
||||
),
|
||||
),
|
||||
],
|
||||
],
|
||||
),
|
||||
);
|
||||
|
||||
Widget _material(BuildContext context) => Wrap(
|
||||
spacing: 8,
|
||||
children: [
|
||||
DropdownButton<String>(
|
||||
value: controller.sort,
|
||||
isExpanded: true,
|
||||
onChanged: (v) {
|
||||
if (v != null) controller.setSort(v);
|
||||
},
|
||||
items: _sorts
|
||||
.map((e) => DropdownMenuItem(value: e.$1, child: Text(e.$2)))
|
||||
.toList(),
|
||||
),
|
||||
DropdownButton<String>(
|
||||
value: controller.scheduled,
|
||||
isExpanded: true,
|
||||
onChanged: (v) {
|
||||
if (v != null) controller.setScheduled(v);
|
||||
},
|
||||
items: _schedules
|
||||
.map((e) => DropdownMenuItem(value: e.$1, child: Text(e.$2)))
|
||||
.toList(),
|
||||
),
|
||||
for (final status in _statuses)
|
||||
FilterChip(
|
||||
label: Text(_title(status)),
|
||||
selected: controller.statuses.contains(status),
|
||||
onSelected: (_) => controller.setStatus(status),
|
||||
),
|
||||
],
|
||||
);
|
||||
|
||||
Future<void> _choose(
|
||||
BuildContext context,
|
||||
String title,
|
||||
List<(String, String)> values,
|
||||
String selected,
|
||||
ValueChanged<String> onSelected,
|
||||
) async {
|
||||
final value = await showCupertinoModalPopup<String>(
|
||||
context: context,
|
||||
builder: (context) => CupertinoActionSheet(
|
||||
title: Text(title),
|
||||
actions: [
|
||||
for (final option in values)
|
||||
CupertinoActionSheetAction(
|
||||
onPressed: () => Navigator.pop(context, option.$1),
|
||||
child: Text(option.$2),
|
||||
),
|
||||
],
|
||||
cancelButton: CupertinoActionSheetAction(
|
||||
onPressed: () => Navigator.pop(context),
|
||||
child: const Text('Cancel'),
|
||||
),
|
||||
),
|
||||
);
|
||||
if (value != null && value != selected) onSelected(value);
|
||||
}
|
||||
}
|
||||
|
||||
const _sorts = [
|
||||
('newest_first', 'Newest'),
|
||||
('oldest_first', 'Oldest'),
|
||||
('pipeline_name', 'Pipeline'),
|
||||
('status', 'Status'),
|
||||
];
|
||||
const _schedules = [
|
||||
('any', 'Any schedule'),
|
||||
('scheduled', 'Scheduled'),
|
||||
('unscheduled', 'Unscheduled'),
|
||||
];
|
||||
const _statuses = ['queued', 'running', 'waiting', 'succeeded', 'failed'];
|
||||
String _sortLabel(String value) =>
|
||||
_sorts.firstWhere((e) => e.$1 == value, orElse: () => _sorts.first).$2;
|
||||
String _scheduleLabel(String value) => _schedules
|
||||
.firstWhere((e) => e.$1 == value, orElse: () => _schedules.first)
|
||||
.$2;
|
||||
String _title(String value) => '${value[0].toUpperCase()}${value.substring(1)}';
|
||||
@@ -3,19 +3,35 @@ import 'package:flutter/material.dart';
|
||||
|
||||
import '../../../core/api_gateway.dart';
|
||||
import '../../../ui/adaptive/host.dart';
|
||||
import '../../attention/runtime/attention_store.dart';
|
||||
import '../../attention/ui/needs_you_runs_heading.dart';
|
||||
import '../domain/run_models.dart';
|
||||
import 'runs_controller.dart';
|
||||
import 'runs_filters.dart';
|
||||
|
||||
class RunsList extends StatelessWidget {
|
||||
const RunsList({
|
||||
super.key,
|
||||
required this.controller,
|
||||
required this.onSelected,
|
||||
this.syncToken = 0,
|
||||
this.attentionStore = const SharedPreferencesAttentionStore(),
|
||||
this.attentionNow,
|
||||
});
|
||||
|
||||
final RunsController controller;
|
||||
final ValueChanged<num> onSelected;
|
||||
|
||||
/// Advances when the shared socket is replaced, so the attention detector
|
||||
/// rebaselines instead of replaying a transition from before the gap.
|
||||
final int syncToken;
|
||||
|
||||
/// Test and fixture seam for the persisted attention dismissals.
|
||||
final AttentionStore attentionStore;
|
||||
|
||||
/// Deterministic local-day clock for the attention window.
|
||||
final DateTime Function()? attentionNow;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
if (controller.loading && controller.runs.isEmpty) {
|
||||
@@ -31,6 +47,20 @@ class RunsList extends StatelessWidget {
|
||||
return Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.stretch,
|
||||
children: [
|
||||
Padding(
|
||||
padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 0),
|
||||
child: Align(
|
||||
alignment: AlignmentDirectional.centerEnd,
|
||||
child: NeedsYouRunsHeading(
|
||||
rows: controller.runs,
|
||||
frames: controller.repository.gateway.frames,
|
||||
onOpen: (entry) => onSelected(entry.runId),
|
||||
syncToken: syncToken,
|
||||
store: attentionStore,
|
||||
now: attentionNow,
|
||||
),
|
||||
),
|
||||
),
|
||||
if (controller.usage != null)
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
||||
@@ -52,7 +82,7 @@ class RunsList extends StatelessWidget {
|
||||
onChanged: controller.setQuery,
|
||||
),
|
||||
),
|
||||
_selectors(context),
|
||||
RunsFilters(controller: controller),
|
||||
Expanded(
|
||||
child: controller.visibleRuns.isEmpty
|
||||
? const Center(child: Text('No runs found.'))
|
||||
@@ -101,101 +131,6 @@ class RunsList extends StatelessWidget {
|
||||
),
|
||||
);
|
||||
|
||||
Widget _selectors(BuildContext context) {
|
||||
if (usesCupertinoHost(context)) {
|
||||
return Wrap(
|
||||
spacing: 8,
|
||||
children: [
|
||||
CupertinoButton(
|
||||
onPressed: () => _choose(
|
||||
context,
|
||||
'Sort runs',
|
||||
_sorts,
|
||||
controller.sort,
|
||||
controller.setSort,
|
||||
),
|
||||
child: Text('Sort: ${_sortLabel(controller.sort)}'),
|
||||
),
|
||||
CupertinoButton(
|
||||
onPressed: () => _choose(
|
||||
context,
|
||||
'Schedule',
|
||||
_schedules,
|
||||
controller.scheduled,
|
||||
controller.setScheduled,
|
||||
),
|
||||
child: Text('Schedule: ${_scheduleLabel(controller.scheduled)}'),
|
||||
),
|
||||
for (final status in _statuses)
|
||||
CupertinoButton(
|
||||
onPressed: () => controller.setStatus(status),
|
||||
child: Text(
|
||||
'${controller.statuses.contains(status) ? '✓ ' : ''}${_title(status)}',
|
||||
),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
return Wrap(
|
||||
spacing: 8,
|
||||
children: [
|
||||
DropdownButton<String>(
|
||||
value: controller.sort,
|
||||
isExpanded: true,
|
||||
onChanged: (v) {
|
||||
if (v != null) controller.setSort(v);
|
||||
},
|
||||
items: _sorts
|
||||
.map((e) => DropdownMenuItem(value: e.$1, child: Text(e.$2)))
|
||||
.toList(),
|
||||
),
|
||||
DropdownButton<String>(
|
||||
value: controller.scheduled,
|
||||
isExpanded: true,
|
||||
onChanged: (v) {
|
||||
if (v != null) controller.setScheduled(v);
|
||||
},
|
||||
items: _schedules
|
||||
.map((e) => DropdownMenuItem(value: e.$1, child: Text(e.$2)))
|
||||
.toList(),
|
||||
),
|
||||
for (final status in _statuses)
|
||||
FilterChip(
|
||||
label: Text(_title(status)),
|
||||
selected: controller.statuses.contains(status),
|
||||
onSelected: (_) => controller.setStatus(status),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> _choose(
|
||||
BuildContext context,
|
||||
String title,
|
||||
List<(String, String)> values,
|
||||
String selected,
|
||||
ValueChanged<String> onSelected,
|
||||
) async {
|
||||
final value = await showCupertinoModalPopup<String>(
|
||||
context: context,
|
||||
builder: (context) => CupertinoActionSheet(
|
||||
title: Text(title),
|
||||
actions: [
|
||||
for (final option in values)
|
||||
CupertinoActionSheetAction(
|
||||
onPressed: () => Navigator.pop(context, option.$1),
|
||||
child: Text(option.$2),
|
||||
),
|
||||
],
|
||||
cancelButton: CupertinoActionSheetAction(
|
||||
onPressed: () => Navigator.pop(context),
|
||||
child: const Text('Cancel'),
|
||||
),
|
||||
),
|
||||
);
|
||||
if (value != null && value != selected) onSelected(value);
|
||||
}
|
||||
|
||||
Widget _runTile(BuildContext context, JsonMap run) {
|
||||
final identity = runIdentity(run['title'], run['name']);
|
||||
final id = run['id'];
|
||||
@@ -222,22 +157,3 @@ class RunsList extends StatelessWidget {
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const _sorts = [
|
||||
('newest_first', 'Newest'),
|
||||
('oldest_first', 'Oldest'),
|
||||
('pipeline_name', 'Pipeline'),
|
||||
('status', 'Status'),
|
||||
];
|
||||
const _schedules = [
|
||||
('any', 'Any schedule'),
|
||||
('scheduled', 'Scheduled'),
|
||||
('unscheduled', 'Unscheduled'),
|
||||
];
|
||||
const _statuses = ['queued', 'running', 'waiting', 'succeeded', 'failed'];
|
||||
String _sortLabel(String value) =>
|
||||
_sorts.firstWhere((e) => e.$1 == value, orElse: () => _sorts.first).$2;
|
||||
String _scheduleLabel(String value) => _schedules
|
||||
.firstWhere((e) => e.$1 == value, orElse: () => _schedules.first)
|
||||
.$2;
|
||||
String _title(String value) => '${value[0].toUpperCase()}${value.substring(1)}';
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
# Runs-list Needs-you bell wiring
|
||||
|
||||
The landed attention model and native bell/sheet are now registered in the real
|
||||
Runs destination. The bell sits in the Runs list heading area and reads the same
|
||||
`list_runs` rows the screen already loaded; it issues no attention request and
|
||||
adds no poll.
|
||||
|
||||
## Code
|
||||
|
||||
- `lib/features/attention/runtime/attention_store.dart` — the injectable
|
||||
`AttentionStore` seam, a `SharedPreferences` implementation under
|
||||
`pipelines.next.attention.v1` (only that key), and an in-memory implementation
|
||||
for tests/fixtures. Reads and writes are total: an unavailable plugin or full
|
||||
store returns null/false instead of throwing.
|
||||
- `lib/features/attention/runtime/attention_controller.dart` — derives today's
|
||||
ordered entries from rows plus the persisted dismissal set, loads asynchronously,
|
||||
and folds pushed `run_event` frames with the runs feature's existing
|
||||
`foldRunEvent`. The attention transition detector is seeded by authoritative
|
||||
list reads, reseeded on reconnect, and keeps emitted keys, so a failure/wait
|
||||
that appears while the screen is open reaches the bell once while a reconnect
|
||||
never replays it. Dismissals update memory and notify before the store write, so
|
||||
a slow or failed write cannot block the sheet. Pushed `title`/`name`/`diagnostic`
|
||||
are retained because the lifecycle fold does not carry the row's attention text.
|
||||
- `lib/features/attention/ui/needs_you_runs_heading.dart` — owns the controller
|
||||
and shared-frame subscription for the destination, passes the dismissed list to
|
||||
the landed `NeedsYouBell`, and opens the existing run through `RunsList`'s
|
||||
`onSelected` (the existing run route).
|
||||
- `lib/features/runs/ui/runs_list.dart` — small heading insert plus injectable
|
||||
store/clock and reconnect token; no other destination is touched.
|
||||
- `lib/features/runs/screen.dart` — forwards the reconnect token and the test
|
||||
seam to the list.
|
||||
- `lib/features/runs/ui/runs_filters.dart` — the existing filter controls moved
|
||||
out of the list file unchanged for Material, with the Cupertino strip made
|
||||
horizontally scrollable. At 320 logical px / 2x the old wrapping strip alone
|
||||
made the Runs `Column` overflow before the attention change; one native row is
|
||||
the same narrow-toolbar shape the browser uses and keeps every control
|
||||
reachable. File split keeps `runs_list.dart` at 159 lines.
|
||||
|
||||
The bell keeps the native `NeedsYouBell` semantics (`Notifications` /
|
||||
`Notifications, N needing attention`), shows no badge when empty, and uses the
|
||||
already-landed Material bottom sheet / Cupertino popup. Failed rows dismiss before
|
||||
opening; Decision rows open without dismissing; Clear all uses the snapshot the
|
||||
sheet captured when it opened. Dismissals survive a screen rebuild through the
|
||||
same store.
|
||||
|
||||
## Verification
|
||||
|
||||
- `flutter test` — 966 tests passed.
|
||||
- Focused `flutter test test/features/attention/runtime` — 20 tests passed:
|
||||
rows -> entries, export waits and yesterday excluded, dismissal persistence
|
||||
across a rebuilt controller, slow write does not block, failed read/write is
|
||||
harmless, clear-all snapshot leaves a later arrival, live failed frame adds an
|
||||
entry, a frame can create a new run summary, reconnect keeps dismissals and
|
||||
emitted keys, empty state keeps the bell and hides its badge, both hosts at
|
||||
320 logical px / 2x with no list/sheet overflow, and the SharedPreferences key
|
||||
ownership test.
|
||||
- `flutter analyze` — no issues.
|
||||
- `flutter build web` — normal `lib/main.dart` built successfully.
|
||||
- Real browser (`tool/attention_wiring_probe.mjs`, isolated `startFixture`, two
|
||||
fresh app boots, one shared socket each): four captures in
|
||||
`public/attention-wiring/` at 320 logical px / 2x:
|
||||
`attention-runs-cupertino-bell-320x2.png`,
|
||||
`attention-runs-cupertino-sheet-320x2.png`,
|
||||
`attention-runs-material-bell-320x2.png`,
|
||||
`attention-runs-material-sheet-320x2.png`.
|
||||
The drive asserted the accessible count `Notifications, 2 needing attention`,
|
||||
both void rows absent, the `Dismiss ...` names and Clear all, and viewed both
|
||||
PNGs. The fixture list held a running row and an `export_pending_sequence`
|
||||
wait that did not enter the sheet; the fixture served one connection and no
|
||||
`get_run`/attention request (`listRuns: 4` across the two boots, the existing
|
||||
screen loads). Both bell and sheet captures were inspected.
|
||||
|
||||
`tool/runs_probe_server.mjs` now accepts an optional `runs` list so this fixture
|
||||
can use current-day timestamps without changing the existing runs probe's
|
||||
default data. No legacy driver was edited.
|
||||
|
||||
## Not done / limits
|
||||
|
||||
- No commit, push, merge, deployment, preview cutover or service restart.
|
||||
- Notification permission/tray delivery remains separate work; the transition
|
||||
ledger is exposed for that wiring but no permission is requested here.
|
||||
- Android/iOS builds and real devices were not run; web only, as required.
|
||||
- The fixture is isolated (loopback, its own browser profile) and does not touch
|
||||
operator runs, chats, storage or production credentials.
|
||||
@@ -0,0 +1,250 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
|
||||
import 'package:pipelines_app/features/attention/runtime/attention_controller.dart';
|
||||
import 'package:pipelines_app/features/attention/runtime/attention_store.dart';
|
||||
|
||||
final _now = DateTime(2026, 10, 22, 12);
|
||||
|
||||
String _at(Duration before) => _now.subtract(before).toIso8601String();
|
||||
|
||||
Map<String, dynamic> _run(
|
||||
int id,
|
||||
String status, {
|
||||
String name = 'release',
|
||||
String? title,
|
||||
Duration age = const Duration(hours: 1),
|
||||
String diagnostic = '',
|
||||
Object? exportPending,
|
||||
Map<String, dynamic> extra = const {},
|
||||
}) => {
|
||||
'id': id,
|
||||
'name': name,
|
||||
'title': title ?? 'Run $id',
|
||||
'status': status,
|
||||
'diagnostic': diagnostic,
|
||||
'created_at': _at(age),
|
||||
'finished_at': _at(age - const Duration(minutes: 5)),
|
||||
'export_pending_sequence': ?exportPending,
|
||||
...extra,
|
||||
};
|
||||
|
||||
AttentionController _controller(AttentionStore store) =>
|
||||
AttentionController(store: store, now: () => _now);
|
||||
|
||||
class _SlowStore extends MemoryAttentionStore {
|
||||
final gate = Completer<bool>();
|
||||
|
||||
@override
|
||||
Future<bool> write(String value) {
|
||||
writes++;
|
||||
stored = value;
|
||||
return gate.future;
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
group('entries from the rows the Runs destination already holds', () {
|
||||
test('only failed and human waiting rows become entries', () async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([
|
||||
_run(1, 'running'),
|
||||
_run(2, 'succeeded'),
|
||||
_run(3, 'queued'),
|
||||
_run(4, 'canceled'),
|
||||
_run(5, 'failed', diagnostic: 'Stage 2 failed'),
|
||||
_run(6, 'waiting', title: 'Approve the release'),
|
||||
]);
|
||||
|
||||
expect(controller.entries.map((entry) => entry.key), [
|
||||
'6:Decision',
|
||||
'5:Failed',
|
||||
]);
|
||||
expect(controller.entries.last.detail, 'Stage 2 failed');
|
||||
});
|
||||
|
||||
test('export handoffs and yesterday do not ask the operator', () async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([
|
||||
_run(1, 'waiting', exportPending: 4),
|
||||
_run(2, 'waiting', exportPending: ' 2 '),
|
||||
_run(3, 'waiting', exportPending: 0),
|
||||
_run(4, 'failed', age: const Duration(days: 1, hours: 2)),
|
||||
_run(5, 'waiting', age: const Duration(days: 1)),
|
||||
]);
|
||||
|
||||
expect(controller.entries.map((entry) => entry.runId), [3]);
|
||||
});
|
||||
});
|
||||
|
||||
group('dismissal persistence', () {
|
||||
test('a dismissed identity survives a rebuilt controller', () async {
|
||||
final store = MemoryAttentionStore();
|
||||
final first = _controller(store);
|
||||
await first.load();
|
||||
first.seedRows([_run(7, 'failed')]);
|
||||
final entry = first.entries.single;
|
||||
|
||||
expect(await first.dismiss(entry), isTrue);
|
||||
expect(first.entries, isEmpty);
|
||||
expect(store.stored, encodeAttentionDismissals({'7:Failed'}));
|
||||
first.dispose();
|
||||
|
||||
final rebuilt = _controller(store);
|
||||
addTearDown(rebuilt.dispose);
|
||||
await rebuilt.load();
|
||||
rebuilt.seedRows([_run(7, 'failed')]);
|
||||
expect(rebuilt.dismissed, {'7:Failed'});
|
||||
expect(rebuilt.entries, isEmpty);
|
||||
});
|
||||
|
||||
test('Clear all applies only the snapshot, leaving later arrivals', () async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([_run(1, 'failed'), _run(2, 'waiting')]);
|
||||
final snapshot = attentionDismissalSnapshot(controller.entries);
|
||||
|
||||
// A third run arrives while the sheet is open. Clear all must not know it.
|
||||
controller.seedRows([
|
||||
_run(1, 'failed'),
|
||||
_run(2, 'waiting'),
|
||||
_run(3, 'failed'),
|
||||
]);
|
||||
expect(await controller.clearAll(snapshot), isTrue);
|
||||
|
||||
expect(controller.dismissed, {'1:Failed', '2:Decision'});
|
||||
expect(controller.entries.map((entry) => entry.key), ['3:Failed']);
|
||||
});
|
||||
|
||||
test('a slow write never holds the bell or entries back', () async {
|
||||
final store = _SlowStore();
|
||||
final controller = _controller(store);
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([_run(4, 'failed')]);
|
||||
final entry = controller.entries.single;
|
||||
|
||||
final pending = controller.dismiss(entry);
|
||||
expect(controller.entries, isEmpty, reason: 'memory applies first');
|
||||
expect(store.stored, encodeAttentionDismissals({'4:Failed'}));
|
||||
store.gate.complete(true);
|
||||
expect(await pending, isTrue);
|
||||
});
|
||||
|
||||
test('failed reads and writes are total and keep this session', () async {
|
||||
final store = MemoryAttentionStore()
|
||||
..failReads = true
|
||||
..failWrites = true;
|
||||
final controller = _controller(store);
|
||||
addTearDown(controller.dispose);
|
||||
|
||||
await expectLater(controller.load(), completes);
|
||||
expect(controller.loaded, isTrue);
|
||||
expect(controller.dismissed, isEmpty);
|
||||
|
||||
controller.seedRows([_run(8, 'failed')]);
|
||||
final entry = controller.entries.single;
|
||||
expect(await controller.dismiss(entry), isFalse);
|
||||
expect(controller.dismissed, {'8:Failed'});
|
||||
expect(controller.entries, isEmpty);
|
||||
});
|
||||
});
|
||||
|
||||
group('pushed frames and reconnect', () {
|
||||
test('a live frame that becomes failed appears without a reload', () async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([_run(1, 'running')]);
|
||||
expect(controller.entries, isEmpty);
|
||||
|
||||
controller.observeFrame({
|
||||
'type': 'run_event',
|
||||
'run_id': 1,
|
||||
'status': 'failed',
|
||||
'diagnostic': 'Stage 4 failed',
|
||||
'finished_at': _at(const Duration(minutes: 1)),
|
||||
});
|
||||
|
||||
expect(controller.entries.map((entry) => entry.key), ['1:Failed']);
|
||||
expect(controller.entries.single.detail, 'Stage 4 failed');
|
||||
expect(controller.transitions.map((item) => item.key), ['1:Failed']);
|
||||
|
||||
// The same state again is not a new transition.
|
||||
controller.observeFrame({
|
||||
'type': 'run_event',
|
||||
'run_id': 1,
|
||||
'status': 'failed',
|
||||
'diagnostic': 'Stage 4 failed',
|
||||
});
|
||||
expect(controller.entries, hasLength(1));
|
||||
expect(controller.transitions, hasLength(1));
|
||||
});
|
||||
|
||||
test('a live frame for a new run can create its own summary', () async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows(const []);
|
||||
|
||||
controller.observeFrame({
|
||||
'type': 'run_event',
|
||||
'run_id': 9,
|
||||
'pipeline_id': 10,
|
||||
'name': 'nightly',
|
||||
'title': 'Nightly audit',
|
||||
'status': 'waiting',
|
||||
'created_at': _at(const Duration(minutes: 3)),
|
||||
});
|
||||
|
||||
expect(controller.entries.single.runId, 9);
|
||||
expect(controller.entries.single.kind, AttentionKind.decision);
|
||||
});
|
||||
|
||||
test(
|
||||
'a reconnect reseed keeps dismissals and does not re-notify',
|
||||
() async {
|
||||
final controller = _controller(MemoryAttentionStore());
|
||||
addTearDown(controller.dispose);
|
||||
await controller.load();
|
||||
controller.seedRows([_run(1, 'running'), _run(2, 'failed')]);
|
||||
final failed = controller.entries.single;
|
||||
expect(await controller.dismiss(failed), isTrue);
|
||||
|
||||
controller.observeFrame({
|
||||
'type': 'run_event',
|
||||
'run_id': 1,
|
||||
'status': 'failed',
|
||||
});
|
||||
expect(controller.transitions, hasLength(1));
|
||||
|
||||
controller.resetForReconnect();
|
||||
controller.seedRows([
|
||||
_run(1, 'failed'),
|
||||
_run(2, 'failed'),
|
||||
], reconnect: true);
|
||||
|
||||
expect(controller.dismissed, {'2:Failed'});
|
||||
expect(controller.entries.map((entry) => entry.key), ['1:Failed']);
|
||||
expect(
|
||||
controller.transitions,
|
||||
hasLength(1),
|
||||
reason: 'the reconnect baseline is already failed for run 1',
|
||||
);
|
||||
|
||||
controller.observeFrame({
|
||||
'type': 'run_event',
|
||||
'run_id': 1,
|
||||
'status': 'failed',
|
||||
});
|
||||
expect(controller.transitions, hasLength(1));
|
||||
},
|
||||
);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/attention/runtime/attention_store.dart';
|
||||
import 'package:pipelines_app/features/attention/ui/needs_you_keys.dart';
|
||||
|
||||
import 'attention_runs_test_support.dart';
|
||||
|
||||
/// The hardest real-app case: a narrow phone at a doubled text scale. Both the
|
||||
/// Runs list chrome and the native sheet must keep the bell and every action
|
||||
/// inside the viewport.
|
||||
void main() {
|
||||
testWidgets('both hosts fit the bell and sheet at 320 logical px and 2x', (
|
||||
tester,
|
||||
) async {
|
||||
tester.view.devicePixelRatio = 2;
|
||||
tester.view.physicalSize = const Size(640, 1280);
|
||||
addTearDown(tester.view.resetPhysicalSize);
|
||||
addTearDown(tester.view.resetDevicePixelRatio);
|
||||
final gateway = AttentionRunsGateway();
|
||||
addTearDown(gateway.framesController.close);
|
||||
|
||||
for (final native in [false, true]) {
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: MemoryAttentionStore(),
|
||||
runs: [
|
||||
attentionRun(
|
||||
1,
|
||||
'waiting',
|
||||
title: 'Approve a release candidate at 320 px',
|
||||
),
|
||||
attentionRun(
|
||||
2,
|
||||
'failed',
|
||||
title: 'A failed run with a label long enough to wrap',
|
||||
diagnostic: 'Stage 3 stopped because the credential is missing.',
|
||||
),
|
||||
],
|
||||
request: native ? 1 : 0,
|
||||
textScale: 2,
|
||||
key: ValueKey(native),
|
||||
);
|
||||
expect(find.byKey(attentionBellKey), findsOneWidget);
|
||||
final listError = tester.takeException();
|
||||
expect(
|
||||
listError,
|
||||
isNull,
|
||||
reason: listError is FlutterError
|
||||
? '${native ? 'Cupertino' : 'Material'} list: ${listError.toStringDeep()}'
|
||||
: '${native ? 'Cupertino' : 'Material'} list: $listError',
|
||||
);
|
||||
await openAttentionSheet(tester);
|
||||
final sheetError = tester.takeException();
|
||||
expect(
|
||||
sheetError,
|
||||
isNull,
|
||||
reason: sheetError is FlutterError
|
||||
? '${native ? 'Cupertino' : 'Material'} sheet: ${sheetError.toStringDeep()}'
|
||||
: '${native ? 'Cupertino' : 'Material'} sheet: $sheetError',
|
||||
);
|
||||
final sheet = tester.getRect(find.byKey(attentionSheetKey));
|
||||
expect(sheet.left, greaterThanOrEqualTo(0));
|
||||
expect(sheet.right, lessThanOrEqualTo(320));
|
||||
expect(sheet.top, greaterThanOrEqualTo(0));
|
||||
expect(sheet.bottom, lessThanOrEqualTo(640));
|
||||
await tester.binding.handlePopRoute();
|
||||
await tester.pumpAndSettle();
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/cupertino.dart';
|
||||
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/attention/runtime/attention_store.dart';
|
||||
import 'package:pipelines_app/features/attention/ui/needs_you_keys.dart';
|
||||
import 'package:pipelines_app/features/runs/screen.dart';
|
||||
|
||||
/// A fixed local noon so the attention local-day window is deterministic.
|
||||
final attentionTestNow = DateTime(2026, 10, 22, 12);
|
||||
|
||||
Map<String, dynamic> attentionRun(
|
||||
int id,
|
||||
String status, {
|
||||
required String title,
|
||||
String name = 'release',
|
||||
String diagnostic = '',
|
||||
}) => {
|
||||
'id': id,
|
||||
'name': name,
|
||||
'title': title,
|
||||
'status': status,
|
||||
'diagnostic': diagnostic,
|
||||
'created_at': attentionTestNow
|
||||
.subtract(const Duration(hours: 1))
|
||||
.toIso8601String(),
|
||||
'finished_at': attentionTestNow
|
||||
.subtract(const Duration(minutes: 30))
|
||||
.toIso8601String(),
|
||||
};
|
||||
|
||||
/// The two requests the Runs destination makes; no attention request exists.
|
||||
class AttentionRunsGateway implements ApiGateway {
|
||||
final framesController = StreamController<JsonMap>.broadcast();
|
||||
final listRequests = <Completer<JsonMap>>[];
|
||||
final detailRequests = <num, List<Completer<JsonMap>>>{};
|
||||
|
||||
@override
|
||||
Stream<JsonMap> get frames => framesController.stream;
|
||||
|
||||
@override
|
||||
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
|
||||
final request = Completer<JsonMap>();
|
||||
if (type == 'list_runs') {
|
||||
listRequests.add(request);
|
||||
} else if (type == 'get_run') {
|
||||
final id = fields['run_id'] as num;
|
||||
detailRequests.putIfAbsent(id, () => []).add(request);
|
||||
} else {
|
||||
request.completeError(UnsupportedError(type));
|
||||
}
|
||||
return request.future;
|
||||
}
|
||||
|
||||
void replyList(int index, List<JsonMap> runs) =>
|
||||
listRequests[index].complete({'runs': runs});
|
||||
|
||||
void replyDetail(num id, JsonMap detail) =>
|
||||
detailRequests[id]!.first.complete({'run_detail': detail});
|
||||
}
|
||||
|
||||
Widget attentionRunsApp(
|
||||
AttentionRunsGateway gateway, {
|
||||
required bool cupertino,
|
||||
required AttentionStore store,
|
||||
double textScale = 1,
|
||||
Key? key,
|
||||
}) {
|
||||
Widget scaled(BuildContext context, Widget? child) => MediaQuery(
|
||||
data: MediaQuery.of(
|
||||
context,
|
||||
).copyWith(textScaler: TextScaler.linear(textScale)),
|
||||
child: child!,
|
||||
);
|
||||
final screen = RunsScreen(
|
||||
key: key,
|
||||
gateway: gateway,
|
||||
attentionStore: store,
|
||||
attentionNow: () => attentionTestNow,
|
||||
);
|
||||
if (cupertino) {
|
||||
return CupertinoApp(
|
||||
theme: const CupertinoThemeData(brightness: Brightness.dark),
|
||||
builder: scaled,
|
||||
home: CupertinoPageScaffold(child: screen),
|
||||
);
|
||||
}
|
||||
return MaterialApp(
|
||||
theme: ThemeData(platform: TargetPlatform.android),
|
||||
builder: scaled,
|
||||
home: Scaffold(body: screen),
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> mountAttentionRuns(
|
||||
WidgetTester tester,
|
||||
AttentionRunsGateway gateway, {
|
||||
required bool cupertino,
|
||||
required AttentionStore store,
|
||||
required List<JsonMap> runs,
|
||||
int request = 0,
|
||||
double textScale = 1,
|
||||
Key? key,
|
||||
}) async {
|
||||
await tester.pumpWidget(
|
||||
attentionRunsApp(
|
||||
gateway,
|
||||
cupertino: cupertino,
|
||||
store: store,
|
||||
textScale: textScale,
|
||||
key: key,
|
||||
),
|
||||
);
|
||||
await tester.pump();
|
||||
gateway.replyList(request, runs);
|
||||
await tester.pump();
|
||||
await tester.pump();
|
||||
}
|
||||
|
||||
Future<void> openAttentionSheet(WidgetTester tester) async {
|
||||
await tester.tap(find.byKey(attentionBellKey));
|
||||
await tester.pumpAndSettle();
|
||||
}
|
||||
@@ -0,0 +1,196 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
|
||||
import 'package:pipelines_app/features/attention/runtime/attention_store.dart';
|
||||
import 'package:pipelines_app/features/attention/ui/needs_you_keys.dart';
|
||||
|
||||
import 'attention_runs_test_support.dart';
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
late AttentionRunsGateway gateway;
|
||||
|
||||
setUp(() => gateway = AttentionRunsGateway());
|
||||
tearDown(() => gateway.framesController.close());
|
||||
|
||||
for (final native in [false, true]) {
|
||||
final host = native ? 'Cupertino' : 'Material';
|
||||
|
||||
testWidgets(
|
||||
'$host Runs list bell opens the native sheet and dismisses one',
|
||||
(tester) async {
|
||||
final semantics = tester.ensureSemantics();
|
||||
final store = MemoryAttentionStore();
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: store,
|
||||
runs: [
|
||||
attentionRun(1, 'waiting', title: 'Approve the release'),
|
||||
attentionRun(
|
||||
2,
|
||||
'failed',
|
||||
title: 'Ship the release',
|
||||
diagnostic: 'Stage 2',
|
||||
),
|
||||
attentionRun(3, 'waiting', title: 'Machine export')
|
||||
..['export_pending_sequence'] = 2,
|
||||
attentionRun(4, 'running', title: 'Still running'),
|
||||
],
|
||||
);
|
||||
|
||||
expect(
|
||||
find.bySemanticsLabel('Notifications, 2 needing attention'),
|
||||
findsOneWidget,
|
||||
);
|
||||
await openAttentionSheet(tester);
|
||||
expect(find.byKey(attentionSheetKey), findsOneWidget);
|
||||
expect(find.byKey(attentionRowKey('3:Decision')), findsNothing);
|
||||
expect(find.byKey(attentionRowKey('4:Failed')), findsNothing);
|
||||
expect(find.byKey(attentionRowKey('2:Failed')), findsOneWidget);
|
||||
|
||||
await tester.tap(find.byKey(attentionDismissKey('2:Failed')));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(attentionSheetKey), findsOneWidget);
|
||||
expect(find.byKey(attentionRowKey('2:Failed')), findsNothing);
|
||||
expect(store.stored, encodeAttentionDismissals({'2:Failed'}));
|
||||
|
||||
// Closing and rebuilding from the same store keeps the dismissal.
|
||||
await tester.binding.handlePopRoute();
|
||||
await tester.pumpAndSettle();
|
||||
await tester.pumpWidget(const SizedBox());
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: store,
|
||||
runs: [
|
||||
attentionRun(1, 'waiting', title: 'Approve the release'),
|
||||
attentionRun(
|
||||
2,
|
||||
'failed',
|
||||
title: 'Ship the release',
|
||||
diagnostic: 'Stage 2',
|
||||
),
|
||||
],
|
||||
request: 1,
|
||||
key: const ValueKey('rebuilt'),
|
||||
);
|
||||
expect(
|
||||
find.bySemanticsLabel('Notifications, 1 needing attention'),
|
||||
findsOneWidget,
|
||||
);
|
||||
semantics.dispose();
|
||||
},
|
||||
);
|
||||
|
||||
testWidgets('$host rows follow the browser open/dismiss rules', (
|
||||
tester,
|
||||
) async {
|
||||
final store = MemoryAttentionStore();
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: store,
|
||||
runs: [
|
||||
attentionRun(1, 'waiting', title: 'Approve the release'),
|
||||
attentionRun(2, 'failed', title: 'Ship the release'),
|
||||
],
|
||||
);
|
||||
|
||||
await openAttentionSheet(tester);
|
||||
await tester.tap(find.byKey(attentionRowKey('1:Decision')));
|
||||
await tester.pump();
|
||||
await tester.pump(const Duration(milliseconds: 400));
|
||||
expect(gateway.detailRequests[1], hasLength(1));
|
||||
expect(
|
||||
store.stored,
|
||||
isNull,
|
||||
reason: 'a Decision opens without dismissing',
|
||||
);
|
||||
gateway.replyDetail(1, {'id': 1, 'title': 'Approve the release'});
|
||||
await tester.pump();
|
||||
await tester.pumpAndSettle();
|
||||
|
||||
await tester.tap(find.text(native ? 'Back' : 'Back to list'));
|
||||
await tester.pump();
|
||||
await openAttentionSheet(tester);
|
||||
await tester.tap(find.byKey(attentionRowKey('2:Failed')));
|
||||
await tester.pump();
|
||||
await tester.pump(const Duration(milliseconds: 400));
|
||||
expect(gateway.detailRequests[2], hasLength(1));
|
||||
expect(store.stored, encodeAttentionDismissals({'2:Failed'}));
|
||||
gateway.replyDetail(2, {'id': 2, 'title': 'Ship the release'});
|
||||
await tester.pump();
|
||||
});
|
||||
|
||||
testWidgets('$host live frame and Clear-all snapshot reach the bell', (
|
||||
tester,
|
||||
) async {
|
||||
final semantics = tester.ensureSemantics();
|
||||
final store = MemoryAttentionStore();
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: store,
|
||||
runs: [attentionRun(1, 'failed', title: 'First failure')],
|
||||
);
|
||||
expect(
|
||||
find.bySemanticsLabel('Notifications, 1 needing attention'),
|
||||
findsOneWidget,
|
||||
);
|
||||
|
||||
await openAttentionSheet(tester);
|
||||
gateway.framesController.add({
|
||||
'type': 'run_event',
|
||||
'run_id': 9,
|
||||
'pipeline_id': 4,
|
||||
'name': 'nightly',
|
||||
'title': 'Arrived while open',
|
||||
'status': 'waiting',
|
||||
'created_at': attentionTestNow
|
||||
.subtract(const Duration(minutes: 5))
|
||||
.toIso8601String(),
|
||||
});
|
||||
await tester.pump();
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(attentionRowKey('9:Decision')), findsOneWidget);
|
||||
|
||||
await tester.tap(find.byKey(attentionClearAllKey));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(attentionRowKey('1:Failed')), findsNothing);
|
||||
expect(
|
||||
find.byKey(attentionRowKey('9:Decision')),
|
||||
findsOneWidget,
|
||||
reason: 'Clear all acts on the snapshot it opened with',
|
||||
);
|
||||
expect(store.stored, encodeAttentionDismissals({'1:Failed'}));
|
||||
semantics.dispose();
|
||||
});
|
||||
|
||||
testWidgets('$host empty runs hide the badge but keep the bell', (
|
||||
tester,
|
||||
) async {
|
||||
final semantics = tester.ensureSemantics();
|
||||
await mountAttentionRuns(
|
||||
tester,
|
||||
gateway,
|
||||
cupertino: native,
|
||||
store: MemoryAttentionStore(),
|
||||
runs: const [],
|
||||
);
|
||||
|
||||
expect(find.byKey(attentionBellKey), findsOneWidget);
|
||||
expect(find.byKey(attentionBadgeKey), findsNothing);
|
||||
expect(find.bySemanticsLabel('Notifications'), findsOneWidget);
|
||||
await openAttentionSheet(tester);
|
||||
expect(find.text('Nothing needs you right now.'), findsOneWidget);
|
||||
expect(find.byKey(attentionClearAllKey), findsNothing);
|
||||
semantics.dispose();
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
|
||||
import 'package:pipelines_app/features/attention/runtime/attention_store.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
|
||||
test('reads and writes only the attention model key', () async {
|
||||
SharedPreferences.setMockInitialValues(<String, Object>{
|
||||
attentionStorageKey: '["7:Failed"]',
|
||||
'pipelines.next.workspace.v1': '/srv/keep',
|
||||
});
|
||||
const store = SharedPreferencesAttentionStore();
|
||||
|
||||
expect(await store.read(), '["7:Failed"]');
|
||||
expect(await store.write('["8:Decision"]'), isTrue);
|
||||
|
||||
final preferences = await SharedPreferences.getInstance();
|
||||
expect(preferences.getString(attentionStorageKey), '["8:Decision"]');
|
||||
expect(
|
||||
preferences.getString('pipelines.next.workspace.v1'),
|
||||
'/srv/keep',
|
||||
reason: 'another owned preference must not be rewritten',
|
||||
);
|
||||
});
|
||||
|
||||
test('an empty store reads as null and the key stays namespaced', () async {
|
||||
SharedPreferences.setMockInitialValues(<String, Object>{});
|
||||
const store = SharedPreferencesAttentionStore();
|
||||
|
||||
expect(await store.read(), isNull);
|
||||
expect(attentionStorageKey, 'pipelines.next.attention.v1');
|
||||
expect(await store.write('[]'), isTrue);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
// Real-browser acceptance for the Needs-you bell in the Runs destination.
|
||||
//
|
||||
// flutter build web
|
||||
// OPENCODE_ARTIFACT_DIR=<dir> node tool/attention_wiring_probe.mjs build/web
|
||||
//
|
||||
// The fixture serves the normal app bundle and answers list_runs over the same
|
||||
// origin, so this is the real Runs screen and the real shared socket. It touches
|
||||
// no production server, operator run or browser profile. The list carries one
|
||||
// failed run, one human wait, plus a running and a machine export wait that must
|
||||
// not reach the bell. Each native host is captured at 320 logical px / 2x.
|
||||
import { spawn, execFile } from 'node:child_process';
|
||||
import { promisify } from 'node:util';
|
||||
import { once } from 'node:events';
|
||||
import { existsSync } from 'node:fs';
|
||||
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
|
||||
import { join, resolve } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { setTimeout as delay } from 'node:timers/promises';
|
||||
|
||||
import { startFixture } from './runs_probe_server.mjs';
|
||||
|
||||
const output = process.env.OPENCODE_ARTIFACT_DIR;
|
||||
if (!output) throw new Error('Set OPENCODE_ARTIFACT_DIR for the probe captures');
|
||||
await mkdir(output, { recursive: true });
|
||||
const root = resolve(process.argv[2] ?? 'build/web');
|
||||
|
||||
const now = Date.now();
|
||||
const dayStart = new Date(now);
|
||||
dayStart.setHours(0, 0, 0, 0);
|
||||
const at = (minutes) =>
|
||||
new Date(Math.max(now - minutes * 60_000, dayStart.getTime() + 30_000)).toISOString();
|
||||
const runs = [
|
||||
{ id: 1, title: 'Running fixture', name: 'running-fixture', status: 'running',
|
||||
created_at: at(6), pipeline_id: 10 },
|
||||
{ id: 2, title: 'Approve the release candidate', name: 'release',
|
||||
status: 'waiting', created_at: at(5), finished_at: '', pipeline_id: 10 },
|
||||
{ id: 3, title: 'Nightly audit stopped', name: 'nightly-audit',
|
||||
status: 'failed', diagnostic: 'Stage 3 stopped at the export archive step because the credential is missing.',
|
||||
created_at: at(4), finished_at: at(1), pipeline_id: 10 },
|
||||
{ id: 6, title: 'Machine export wait', name: 'export-handoff',
|
||||
status: 'waiting', export_pending_sequence: 2, created_at: at(3), pipeline_id: 10 },
|
||||
];
|
||||
|
||||
const fixture = await startFixture({ root, runs });
|
||||
// Prove the fixture answered before Chrome starts, so a missing build fails with
|
||||
// a clear message instead of a blank page.
|
||||
const probe = await fetch(`${fixture.url}/`);
|
||||
if (probe.status !== 200 || !(probe.headers.get('content-type') ?? '').startsWith('text/html')) {
|
||||
throw new Error(`Fixture index must be HTML: ${probe.status} ${probe.headers.get('content-type')}`);
|
||||
}
|
||||
await probe.text();
|
||||
|
||||
const chromePath = process.env.CHROME_PATH ?? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
|
||||
if (!existsSync(chromePath)) throw new Error(`Chrome not found at ${chromePath}; set CHROME_PATH`);
|
||||
const profile = await mkdtemp(join(tmpdir(), 'attention-wiring-chrome-'));
|
||||
const chrome = spawn(chromePath, [
|
||||
'--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu',
|
||||
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
|
||||
], { stdio: ['ignore', 'ignore', 'pipe'] });
|
||||
let stderr = '';
|
||||
chrome.stderr.on('data', (data) => { stderr += data; });
|
||||
|
||||
const waitFor = async (check, what) => {
|
||||
for (let i = 0; i < 160; i++) {
|
||||
const value = await check();
|
||||
if (value) return value;
|
||||
await delay(100);
|
||||
}
|
||||
throw new Error(`Timed out waiting for ${what}\n${stderr.slice(-1200)}`);
|
||||
};
|
||||
|
||||
let ws;
|
||||
const captures = [];
|
||||
try {
|
||||
const endpoint = await waitFor(
|
||||
() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1],
|
||||
'Chrome DevTools',
|
||||
);
|
||||
ws = new WebSocket(endpoint);
|
||||
await once(ws, 'open');
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
ws.addEventListener('message', (event) => {
|
||||
const message = JSON.parse(event.data);
|
||||
if (message.id && pending.has(message.id)) {
|
||||
pending.get(message.id)(message);
|
||||
pending.delete(message.id);
|
||||
}
|
||||
});
|
||||
const send = (method, params = {}, sessionId) => new Promise((resolveCall) => {
|
||||
const callId = ++id;
|
||||
pending.set(callId, resolveCall);
|
||||
ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) }));
|
||||
});
|
||||
const target = (await send('Target.createTarget', { url: 'about:blank' })).result.targetId;
|
||||
const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId;
|
||||
await send('Page.enable', {}, session);
|
||||
await send('Runtime.enable', {}, session);
|
||||
|
||||
const evaluate = async (expression) => {
|
||||
const response = await send('Runtime.evaluate', {
|
||||
expression, returnByValue: true, awaitPromise: true,
|
||||
}, session);
|
||||
if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`);
|
||||
if (response.result?.exceptionDetails) {
|
||||
throw new Error(`Page exception: ${JSON.stringify(response.result.exceptionDetails)}`);
|
||||
}
|
||||
return response.result?.result?.value;
|
||||
};
|
||||
const path = () => evaluate('location.pathname');
|
||||
const semantics = () => evaluate(`[...document.querySelectorAll('flt-semantics')].map((el) => {
|
||||
const r = el.getBoundingClientRect();
|
||||
return { label: (el.getAttribute('aria-label') || el.innerText || '').trim(),
|
||||
role: el.getAttribute('role'), x: r.x, y: r.y, w: r.width, h: r.height };
|
||||
})`);
|
||||
const labels = async () => (await semantics()).map((item) => item.label).filter(Boolean);
|
||||
const text = () => evaluate(`(() => {
|
||||
const chunks = [...document.querySelectorAll('flt-semantics, [aria-label]')]
|
||||
.map((el) => el.getAttribute('aria-label') || el.innerText || '');
|
||||
if (document.body?.innerText) chunks.push(document.body.innerText);
|
||||
return [...new Set(chunks)].join('\\n');
|
||||
})()`);
|
||||
const requireLabel = async (needle) => {
|
||||
await waitFor(async () => (await labels()).some((label) => label.includes(needle)), `label ${JSON.stringify(needle)}`);
|
||||
};
|
||||
const requireText = async (needle) => {
|
||||
await waitFor(async () => (await text()).includes(needle), `text ${JSON.stringify(needle)}`);
|
||||
};
|
||||
const enableSemantics = async () => {
|
||||
await waitFor(
|
||||
() => evaluate("Boolean(document.querySelector('flt-semantics-placeholder'))"),
|
||||
'semantics placeholder',
|
||||
);
|
||||
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
|
||||
await delay(600);
|
||||
};
|
||||
const clickLabel = async (needle, exact = false) => {
|
||||
const clicked = await evaluate(`(() => {
|
||||
const wanted = ${JSON.stringify(needle)};
|
||||
const all = [...document.querySelectorAll('flt-semantics')];
|
||||
const match = (el) => {
|
||||
const label = (el.getAttribute('aria-label') || el.innerText || '').trim();
|
||||
return ${exact ? 'label === wanted' : 'label.includes(wanted)'};
|
||||
};
|
||||
const element = all.find((el) => ['button', 'tab', 'link', 'menuitem'].includes(el.getAttribute('role')) && match(el))
|
||||
|| all.find(match);
|
||||
if (!element) return false;
|
||||
element.click();
|
||||
return true;
|
||||
})()`);
|
||||
if (!clicked) throw new Error(`Could not click ${JSON.stringify(needle)}. Labels: ${JSON.stringify(await labels())}`);
|
||||
await delay(400);
|
||||
};
|
||||
const capture = async (name) => {
|
||||
const data = (await send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false }, session)).result.data;
|
||||
const pathName = join(output, `${name}.png`);
|
||||
await writeFile(pathName, Buffer.from(data, 'base64'));
|
||||
captures.push(pathName);
|
||||
return pathName;
|
||||
};
|
||||
const ocr = async (file) => (await promisify(execFile)('tesseract', [file, 'stdout'])).stdout;
|
||||
const requireOcr = async (file, needle) => {
|
||||
const read = await ocr(file);
|
||||
if (!read.toLowerCase().includes(needle.toLowerCase())) {
|
||||
throw new Error(`OCR of ${file} lacks ${JSON.stringify(needle)}:\n${read.slice(0, 2000)}`);
|
||||
}
|
||||
};
|
||||
const setPhone = async () => {
|
||||
await send('Emulation.setDeviceMetricsOverride', {
|
||||
width: 320, height: 640, deviceScaleFactor: 2, mobile: true,
|
||||
}, session);
|
||||
await delay(500);
|
||||
};
|
||||
|
||||
const drive = async (host, userAgent) => {
|
||||
if (userAgent) {
|
||||
await send('Emulation.setUserAgentOverride', userAgent, session);
|
||||
}
|
||||
await setPhone();
|
||||
await send('Page.navigate', { url: `${fixture.url}/` }, session);
|
||||
await enableSemantics();
|
||||
await waitFor(async () => (await path()) === '/pipelines', 'boot route /pipelines');
|
||||
await clickLabel('Runs', true);
|
||||
await waitFor(async () => (await path()) === '/runs', 'runs route');
|
||||
await requireLabel('Notifications, 2 needing attention');
|
||||
const bell = await capture(`attention-runs-${host}-bell-320x2`);
|
||||
await requireOcr(bell, 'Nightly audit stopped');
|
||||
|
||||
await clickLabel('Notifications, 2 needing attention');
|
||||
await requireText('Needs you');
|
||||
await requireText('Approve the release candidate');
|
||||
await requireText('Stage 3 stopped at the export archive step');
|
||||
await requireLabel('Dismiss Approve the release candidate');
|
||||
await requireLabel('Dismiss Nightly audit stopped');
|
||||
await requireLabel('Clear all');
|
||||
const sheetLabels = await labels();
|
||||
if (sheetLabels.some((label) => label.includes('Machine export wait'))) {
|
||||
throw new Error('an export wait leaked into the bell sheet');
|
||||
}
|
||||
if (sheetLabels.some((label) => label.includes('Running fixture'))) {
|
||||
throw new Error('a running run leaked into the bell sheet');
|
||||
}
|
||||
const sheet = await capture(`attention-runs-${host}-sheet-320x2`);
|
||||
await requireOcr(sheet, 'Needs you');
|
||||
return { host, bell, sheet };
|
||||
};
|
||||
|
||||
const cupertino = await drive('cupertino');
|
||||
const material = await drive('material', {
|
||||
userAgent: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
|
||||
platform: 'Linux x86_64',
|
||||
});
|
||||
const state = await (await fetch(`${fixture.url}/fixture/state`)).json();
|
||||
console.log(JSON.stringify({ captures, cupertino, material, fixture: state }, null, 2));
|
||||
} finally {
|
||||
try { ws?.close(); } catch {}
|
||||
chrome.kill('SIGTERM');
|
||||
await rm(profile, { recursive: true, force: true }).catch(() => {});
|
||||
await fixture.close();
|
||||
}
|
||||
@@ -57,9 +57,9 @@ const RUNS = [
|
||||
},
|
||||
];
|
||||
|
||||
function humanDetail(accepted) {
|
||||
function humanDetail(accepted, runs = RUNS) {
|
||||
return {
|
||||
...RUNS.find((run) => run.id === 5),
|
||||
...runs.find((run) => run.id === 5),
|
||||
status: accepted ? 'succeeded' : 'waiting', current_stage: 'gate',
|
||||
input: { prompt: 'Fixture human decision' },
|
||||
graph: { stages: [{ key: 'gate', type: 'human', edges: { approve: '#success' } }] },
|
||||
@@ -79,12 +79,12 @@ const LIVE_EVENT = {
|
||||
finished_at: '2026-10-21T12:05:00Z',
|
||||
};
|
||||
|
||||
function detail(id, live, canceled = false) {
|
||||
function detail(id, live, canceled = false, runs = RUNS) {
|
||||
const status = canceled ? 'canceled'
|
||||
: id === 1 && live ? 'succeeded' : id === 3 ? 'failed' : 'running';
|
||||
return {
|
||||
id,
|
||||
title: RUNS.find((run) => run.id === id)?.title ?? `Run ${id}`,
|
||||
title: runs.find((run) => run.id === id)?.title ?? `Run ${id}`,
|
||||
name: 'fixture-pipeline',
|
||||
status,
|
||||
executing: status === 'running',
|
||||
@@ -310,7 +310,7 @@ async function staticFile(base, pathname, req, res) {
|
||||
* It serves the built probe bundle and upgrades /connect on the same origin, so
|
||||
* the normal web composition infers this server from Uri.base.
|
||||
*/
|
||||
export async function startFixture({ root }) {
|
||||
export async function startFixture({ root, runs = RUNS }) {
|
||||
const base = await realpath(root);
|
||||
const connections = new Set();
|
||||
const sockets = new Set();
|
||||
@@ -436,7 +436,7 @@ export async function startFixture({ root }) {
|
||||
}
|
||||
if (request.type === 'list_runs') {
|
||||
listRuns++;
|
||||
client.send({ id: request.id, type: 'runs', runs: RUNS.map((run) =>
|
||||
client.send({ id: request.id, type: 'runs', runs: runs.map((run) =>
|
||||
canceled.has(run.id) ? { ...run, status: 'canceled', executing: false }
|
||||
: run.id === 5 && decisionAccepted ? { ...run, status: 'succeeded' } : run), usage: null });
|
||||
return;
|
||||
@@ -448,7 +448,7 @@ export async function startFixture({ root }) {
|
||||
// Deliberately slow so the browser sees the pending/Back state;
|
||||
// it must still answer so the serialized request queue continues.
|
||||
setTimeout(() => {
|
||||
client.send({ id: request.id, type: 'run', run_detail: detail(2, live) });
|
||||
client.send({ id: request.id, type: 'run', run_detail: detail(2, live, false, runs) });
|
||||
}, 2500);
|
||||
return;
|
||||
}
|
||||
@@ -461,13 +461,13 @@ export async function startFixture({ root }) {
|
||||
return;
|
||||
}
|
||||
client.send({ id: request.id, type: 'run', run_detail: id === 5
|
||||
? humanDetail(decisionAccepted) : detail(id, live, canceled.has(id)) });
|
||||
? humanDetail(decisionAccepted, runs) : detail(id, live, canceled.has(id), runs) });
|
||||
return;
|
||||
}
|
||||
if (request.type === 'cancel_run' && request.run_id === 4) {
|
||||
cancelRequests.push({ run_id: request.run_id });
|
||||
canceled.add(4);
|
||||
client.send({ id: request.id, type: 'run', run_detail: detail(4, live, true) });
|
||||
client.send({ id: request.id, type: 'run', run_detail: detail(4, live, true, runs) });
|
||||
return;
|
||||
}
|
||||
if (request.type === 'decide_run' && request.run_id === 5 &&
|
||||
@@ -475,7 +475,7 @@ export async function startFixture({ root }) {
|
||||
decisionRequests.push({ run_id: request.run_id, stage: request.stage,
|
||||
option: request.option, ...(request.feedback ? { feedback: request.feedback } : {}) });
|
||||
decisionAccepted = true;
|
||||
client.send({ id: request.id, type: 'run', run_detail: humanDetail(true) });
|
||||
client.send({ id: request.id, type: 'run', run_detail: humanDetail(true, runs) });
|
||||
return;
|
||||
}
|
||||
if (request.type === 'search') {
|
||||
|
||||
Reference in New Issue
Block a user