Files
pipelines/app/test/features/runs/ui/runs_controller_test.dart
T
alan 535dee0805 feat(app): compact runs filter and sort toolbar
Replace the full-width runs dropdowns and status chips with web-shaped
controls: a Material filter popup with checked statuses and triggers, a
sort menu, and removable applied-filter chips; Cupertino gets a compact
Filter/Sort row plus one action sheet with live check marks. Add
RunsController.activeFilterCount and clearFilters(), and use the shared
seven-state run vocabulary. Clarify the singular active-filter tooltip.
2026-10-22 14:20:05 +01:00

403 lines
13 KiB
Dart

import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/runs/data/runs_repository.dart';
import 'package:pipelines_app/features/runs/ui/runs_controller.dart';
class FakeGateway implements ApiGateway {
final framesController = StreamController<JsonMap>.broadcast();
final lists = <Completer<JsonMap>>[];
final details = <num, List<Completer<JsonMap>>>{};
int listCalls = 0;
@override
Stream<JsonMap> get frames => framesController.stream;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
if (type == 'list_runs') {
listCalls++;
final request = Completer<JsonMap>();
lists.add(request);
return request.future;
}
final id = fields['run_id'] as num;
final request = Completer<JsonMap>();
details.putIfAbsent(id, () => []).add(request);
return request.future;
}
void listReply(int index, List<JsonMap> runs) =>
lists[index].complete({'runs': runs});
void detailReply(num id, int index, JsonMap value) =>
details[id]![index].complete({'run_detail': value});
}
void main() {
late FakeGateway gateway;
late RunsController controller;
var disposed = false;
setUp(() {
gateway = FakeGateway();
controller = RunsController(RunsRepository(gateway));
disposed = false;
});
tearDown(() {
if (!disposed) controller.dispose();
gateway.framesController.close();
});
test('late selection response cannot replace latest selection', () async {
final first = controller.select(1);
final second = controller.select(2);
gateway.detailReply(2, 0, {'id': 2});
await second;
gateway.detailReply(1, 0, {'id': 1});
await first;
expect(controller.detail?['id'], 2);
});
test('pending load and selection futures are safe after dispose', () async {
final load = controller.load();
final select = controller.select(1);
controller.dispose();
disposed = true;
gateway.listReply(0, []);
gateway.detailReply(1, 0, {'id': 1});
await Future.wait([load, select]);
});
test('Back cancels scheduled detail refresh', () async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'succeeded',
});
controller.back();
await Future<void>.delayed(const Duration(milliseconds: 220));
expect(gateway.details[1], hasLength(1));
expect(controller.detail, isNull);
});
test('unrelated run event does not refresh selected detail', () async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 2,
'status': 'succeeded',
});
await Future<void>.delayed(const Duration(milliseconds: 220));
expect(gateway.details[1], hasLength(1));
});
test('identity-less event reloads list', () async {
controller.listen(gateway.frames);
gateway.framesController.add({'type': 'run_event', 'status': 'running'});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 1);
gateway.listReply(0, [
{'id': 3},
]);
await Future<void>.delayed(Duration.zero);
expect(controller.runs.single['id'], 3);
expect(controller.loading, isFalse);
});
test(
'full refresh is coalesced and keeps current detail until reply',
() async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'succeeded',
});
await Future<void>.delayed(const Duration(milliseconds: 180));
expect(controller.detail?['id'], 1);
expect(gateway.details[1], hasLength(2));
gateway.detailReply(1, 1, {'id': 1, 'status': 'succeeded'});
await Future<void>.delayed(Duration.zero);
expect(controller.detail?['status'], 'succeeded');
},
);
test('load with initial id clears list and detail loading', () async {
final load = controller.load(7);
expect(controller.loading, isTrue);
gateway.listReply(0, [
{'id': 7},
{'id': 8},
]);
await Future<void>.delayed(Duration.zero);
expect(gateway.details[7], hasLength(1));
expect(controller.loading, isFalse);
expect(controller.detailLoading, isTrue);
gateway.detailReply(7, 0, {'id': 7});
await load;
expect(controller.loading, isFalse);
expect(controller.detailLoading, isFalse);
expect(controller.detail?['id'], 7);
expect(controller.selectedRunId, 7);
});
test('newer list load wins when replies complete out of order', () async {
final first = controller.load();
final second = controller.load();
gateway.listReply(1, [
{'id': 2},
]);
await second;
gateway.listReply(0, [
{'id': 1},
]);
await first;
expect(controller.runs.single['id'], 2);
expect(controller.loading, isFalse);
});
test('list resync leaves the selected detail request valid', () async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({'type': 'run_event', 'status': 'running'});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 1);
gateway.listReply(0, [
{'id': 1, 'status': 'running'},
]);
await Future<void>.delayed(Duration.zero);
expect(controller.detail?['id'], 1);
expect(controller.selectedRunId, 1);
expect(gateway.details[1], hasLength(1));
});
test('manual list load keeps an in-flight detail refresh valid', () async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'succeeded',
});
await Future<void>.delayed(const Duration(milliseconds: 180));
expect(gateway.details[1], hasLength(2));
final load = controller.load();
gateway.listReply(1, [
{'id': 1},
]);
await load;
gateway.detailReply(1, 1, {'id': 1, 'status': 'succeeded'});
await Future<void>.delayed(Duration.zero);
expect(controller.detail?['status'], 'succeeded');
expect(controller.detailLoading, isFalse);
gateway.listReply(0, [
{'id': 1},
]);
});
test('event during a superseded resync still runs one followup', () async {
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 9,
'status': 'running',
});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 1);
final load = controller.load();
expect(gateway.listCalls, 2);
gateway.listReply(1, [
{'id': 1},
]);
await load;
gateway.framesController.add({
'type': 'run_event',
'run_id': 10,
'status': 'running',
});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 2);
gateway.listReply(0, [
{'id': 1},
]);
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 3);
gateway.listReply(2, [
{'id': 1},
{'id': 2},
]);
await Future<void>.delayed(Duration.zero);
expect(controller.runs, hasLength(2));
expect(controller.loading, isFalse);
});
test('unknown run events coalesce into one followup resync', () async {
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 9,
'status': 'running',
});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 1);
expect(controller.loading, isTrue);
gateway.framesController.add({
'type': 'run_event',
'run_id': 10,
'status': 'running',
});
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 1);
gateway.listReply(0, [
{'id': 3},
]);
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 2);
expect(controller.loading, isTrue);
gateway.listReply(1, [
{'id': 3},
{'id': 4},
]);
await Future<void>.delayed(Duration.zero);
expect(gateway.listCalls, 2);
expect(controller.loading, isFalse);
expect(controller.runs, hasLength(2));
});
test(
'selected refresh coalesces and Back ignores the pending reply',
() async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'succeeded',
});
await Future<void>.delayed(const Duration(milliseconds: 180));
expect(gateway.details[1], hasLength(2));
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'failed',
});
await Future<void>.delayed(Duration.zero);
expect(gateway.details[1], hasLength(2));
gateway.detailReply(1, 1, {'id': 1, 'status': 'succeeded'});
await Future<void>.delayed(Duration.zero);
expect(gateway.details[1], hasLength(3));
controller.back();
gateway.detailReply(1, 2, {'id': 1, 'status': 'failed'});
await Future<void>.delayed(Duration.zero);
expect(controller.detail, isNull);
expect(controller.detailLoading, isFalse);
expect(controller.error, isNull);
},
);
test('choosing another run does not display the previous detail', () async {
final first = controller.select(1);
gateway.detailReply(1, 0, {'id': 1});
await first;
final second = controller.select(2);
expect(controller.detail, isNull);
expect(controller.selectedRunId, 2);
expect(controller.detailLoading, isTrue);
gateway.detailReply(2, 0, {'id': 2});
await second;
expect(controller.detail?['id'], 2);
expect(controller.detailLoading, isFalse);
});
test('pending detail refresh is safe after dispose', () async {
final select = controller.select(1);
gateway.detailReply(1, 0, {'id': 1, 'status': 'running'});
await select;
controller.listen(gateway.frames);
gateway.framesController.add({
'type': 'run_event',
'run_id': 1,
'status': 'succeeded',
});
await Future<void>.delayed(const Duration(milliseconds: 180));
expect(gateway.details[1], hasLength(2));
controller.dispose();
disposed = true;
gateway.detailReply(1, 1, {'id': 1, 'status': 'succeeded'});
await Future<void>.delayed(Duration.zero);
expect(controller.detail?['id'], 1);
});
test(
'an accepted rename folds into the selected detail and its list row',
() async {
final load = controller.load();
gateway.listReply(0, [
{'id': 1, 'title': 'Old title', 'status': 'running', 'name': 'one'},
{'id': 2, 'title': 'Other run', 'status': 'running'},
]);
await load;
final first = controller.select(1);
gateway.detailReply(1, 0, {
'id': 1,
'title': 'Old title',
'input': {'prompt': 'stored'},
});
await first;
controller.acceptRunDetail({
'id': 1,
'title': 'Renamed',
'status': 'succeeded',
});
expect(controller.detail?['title'], 'Renamed');
expect(controller.runs.first['title'], 'Renamed');
expect(controller.runs.first['name'], 'one');
expect(controller.runs[1]['title'], 'Other run');
final second = controller.select(2);
gateway.detailReply(2, 0, {'id': 2, 'title': 'Other run'});
await second;
controller.acceptRunDetail({'id': 1, 'title': 'Late rename'});
expect(controller.detail?['id'], 2);
expect(controller.detail?['title'], 'Other run');
expect(controller.runs.first['title'], 'Late rename');
},
);
test('active filter count treats each facet once and clears all', () {
expect(controller.activeFilterCount, 0);
controller.setStatus('failed');
controller.setStatus('running');
expect(controller.activeFilterCount, 1);
controller.setScheduled('scheduled');
controller.setPipeline(4);
expect(controller.activeFilterCount, 3);
controller.clearFilters();
expect(controller.activeFilterCount, 0);
expect(controller.statuses, isEmpty);
expect(controller.pipelineId, isNull);
expect(controller.scheduled, 'any');
expect(controller.timeRange, 'any_time');
});
}