Files
pipelines/app/test/features/attention/notify/notification_delivery_test.dart
T

239 lines
7.7 KiB
Dart

import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
import 'package:pipelines_app/features/attention/notify/notification_bridge.dart';
import 'package:pipelines_app/features/attention/notify/notification_controller.dart';
import 'package:pipelines_app/features/attention/notify/notification_models.dart';
import 'package:pipelines_app/features/attention/notify/notification_store.dart';
import 'notification_test_support.dart';
void main() {
group('a dismissed entry never notifies', () {
test('the detector suppresses it and nothing is posted', () async {
final attention = attentionController();
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(attention.dispose);
addTearDown(notify.dispose);
await attention.load();
await notify.load();
attention.seedRows([runSummary(1, 'running')]);
await attention.dismiss(attentionEntryFor(runSummary(1, 'failed'))!);
attention.observeFrame(runFrame(1, 'failed'));
expect(attention.transitions, isEmpty);
expect(publish(notify, attention), 0);
expect(bridge.shown, isEmpty);
});
test(
'the publish guard records but does not show a dismissed key',
() async {
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
final transition = transitionFor(4);
expect(
notify.publishTransitions(
[transition],
qualifying: {transition.key},
dismissed: {transition.key},
),
0,
);
expect(notify.notified, contains(transition.key));
expect(bridge.shown, isEmpty);
},
);
});
group('batching and the tap seam', () {
test('a burst posts a bounded batch in order, then the rest', () async {
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
final transitions = [for (var id = 1; id <= 7; id++) transitionFor(id)];
final qualifying = {for (final t in transitions) t.key};
expect(notify.publishTransitions(transitions, qualifying: qualifying), 5);
expect(bridge.shown.map((m) => m.runId), [1, 2, 3, 4, 5]);
expect(notify.publishTransitions(transitions, qualifying: qualifying), 2);
expect(bridge.shown.map((m) => m.runId), [1, 2, 3, 4, 5, 6, 7]);
});
test('a tap reports the run and never navigates here', () async {
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
final opened = <int>[];
notify.onOpenRun = opened.add;
expect(
notify.publishTransitions([transitionFor(3)], qualifying: {'3:Failed'}),
1,
);
bridge.taps.single!.call();
expect(opened, [3]);
});
});
group('the ledger cannot be read into by a caller', () {
test('notified is an unmodifiable copy', () async {
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
expect(
notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}),
1,
);
expect(notify.notified, {'1:Failed'});
expect(() => notify.notified.add('9:Failed'), throwsUnsupportedError);
expect(notify.notified, {'1:Failed'});
});
});
group('an unavailable store cannot reach the UI', () {
test('a failed read and write still notify and never throw', () async {
final store = MemoryNotificationStore()
..failReads = true
..failWrites = true;
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(store: store, bridge: bridge);
addTearDown(notify.dispose);
await expectLater(notify.load(), completes);
expect(notify.loaded, isTrue);
expect(notify.notified, isEmpty);
expect(
notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}),
1,
);
await settle();
expect(bridge.shown, hasLength(1));
});
test('a throwing platform post is reported, not propagated', () async {
final bridge = _ThrowingBridge();
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
expect(
notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'}),
0,
);
expect(notify.notified, contains('1:Failed'));
});
test('ledger writes land in call order, one at a time', () async {
final store = _SlowStore();
final bridge = FakeNotificationBridge(permission: 'granted');
final notify = NotificationController(store: store, bridge: bridge);
addTearDown(notify.dispose);
await notify.load();
notify.publishTransitions([transitionFor(1)], qualifying: {'1:Failed'});
notify.publishTransitions(
[transitionFor(2)],
qualifying: {'1:Failed', '2:Failed'},
);
await Future<void>.delayed(const Duration(milliseconds: 40));
expect(store.maxActive, 1, reason: 'the writes must be serialized');
expect(store.stored, contains('"1:Failed"'));
expect(store.stored, contains('"2:Failed"'));
expect(store.writes.last, store.stored);
});
});
group('the platform seam', () {
test('the non-web bridge reports unsupported honestly', () async {
final bridge = createNotificationBridge();
expect(bridge.environment().supported, isFalse);
final notify = NotificationController(
store: MemoryNotificationStore(),
bridge: bridge,
);
addTearDown(notify.dispose);
await notify.load();
expect(notify.permission, NotificationPermissionState.unsupported);
expect(
bridge.show(
const NotificationMessage(
runId: 1,
title: 'A run failed',
body: 'release',
tag: '1:Failed',
),
),
isFalse,
);
});
});
}
/// A store whose writes take a tick, so a racing implementation would overlap
/// them and the last value to land would be the older snapshot.
class _SlowStore implements NotificationStore {
String? stored;
int active = 0;
int maxActive = 0;
final List<String> writes = [];
@override
Future<String?> read() async => stored;
@override
Future<bool> write(String value) async {
active++;
if (active > maxActive) maxActive = active;
await Future<void>.delayed(const Duration(milliseconds: 2));
stored = value;
writes.add(value);
active--;
return true;
}
}
class _ThrowingBridge implements NotificationBridge {
@override
NotificationEnvironment environment() => const NotificationEnvironment(
supported: true,
secureContext: true,
permission: 'granted',
);
@override
Future<String> requestPermission() async => 'granted';
@override
bool show(NotificationMessage message, {void Function()? onTap}) =>
throw StateError('the browser refused to construct a notification');
}