import 'dart:convert'; import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/application/app_session.dart'; import 'package:pipelines_app/core/transport/pipelines_client.dart'; import '../core/transport/pipelines_client_test.dart' show FakeChannel; Future flush() => Future.delayed(Duration.zero); Future waitFor(bool Function() condition, String reason) async { for (var attempt = 0; attempt < 200; attempt++) { if (condition()) return; await Future.delayed(const Duration(milliseconds: 5)); } fail('Timed out: $reason'); } List types(FakeChannel channel) => [ for (final frame in channel.outgoing) (jsonDecode(frame as String) as Map)['type'] as String, ]; void main() { test('Retry preserves an endpoint changed through shared Settings', () async { final endpoints = []; final client = PipelinesClient( channelFactory: (uri) { endpoints.add(uri); return FakeChannel()..readyCompleter.complete(); }, ); final session = AppSession( endpoint: Uri.parse('ws://original.test/connect'), client: client, ); addTearDown(session.dispose); await session.start(); final changed = Uri.parse('ws://selected.test/connect'); await session.client.connect(changed); await session.stop(); await session.retry(); expect(endpoints, [ Uri.parse('ws://original.test/connect'), changed, changed, ]); expect(session.endpoint, changed); }); test( 'start subscribes once, stop unsubscribes, and the app owns the socket', () async { final channel = FakeChannel()..readyCompleter.complete(); final client = PipelinesClient(channelFactory: (_) => channel); final session = AppSession( endpoint: Uri.parse('ws://example.test/connect'), client: client, ); await session.start(); await flush(); expect(session.connected, isTrue); expect(types(channel), ['subscribe']); final frame = jsonDecode(channel.outgoing.single as String) as Map; expect(frame['workspace'], ''); await session.stop(); await flush(); expect(types(channel), ['subscribe', 'unsubscribe']); expect(session.connected, isFalse); session.dispose(); }, ); test('reconnect subscribes the new socket again', () async { final first = FakeChannel()..readyCompleter.complete(); final second = FakeChannel()..readyCompleter.complete(); var sockets = 0; final client = PipelinesClient( channelFactory: (_) => sockets++ == 0 ? first : second, backoffBase: const Duration(milliseconds: 5), ); final session = AppSession( endpoint: Uri.parse('ws://example.test/connect'), client: client, ); addTearDown(session.dispose); await session.start(); await flush(); expect(types(first), ['subscribe']); expect(session.connectionEpoch, 1); first.incoming.addError(StateError('network drop')); await waitFor( () => sockets == 2 && session.connected && second.outgoing.isNotEmpty, 'reconnected socket did not subscribe', ); expect(types(second), ['subscribe']); expect(session.connectionEpoch, 2); }); test('a subscribe ack marks the watch live, a refusal reports it', () async { final channel = FakeChannel()..readyCompleter.complete(); final client = PipelinesClient(channelFactory: (_) => channel); final session = AppSession( endpoint: Uri.parse('ws://example.test/connect'), client: client, ); addTearDown(session.dispose); await session.start(); await flush(); final subscribe = jsonDecode(channel.outgoing.single as String) as Map; expect(session.subscription, RunSubscriptionState.pending); channel.incoming.add( jsonEncode({'id': subscribe['id'], 'type': 'subscribe'}), ); await flush(); expect(session.subscription, RunSubscriptionState.live); expect(session.subscriptionError, isEmpty); session.resubscribe(); await flush(); final repeated = jsonDecode(channel.outgoing.last as String) as Map; expect(repeated['type'], 'subscribe'); channel.incoming.add( jsonEncode({ 'id': repeated['id'], 'type': 'error', 'error': 'too many run subscriptions on this connection', }), ); await flush(); expect(session.subscription, RunSubscriptionState.refused); expect(session.subscriptionError, contains('too many run subscriptions')); }); test('dispose drops the watch and releases the client', () async { final channel = FakeChannel()..readyCompleter.complete(); final client = PipelinesClient(channelFactory: (_) => channel); final session = AppSession( endpoint: Uri.parse('ws://example.test/connect'), client: client, ); await session.start(); await flush(); session.dispose(); await flush(); expect(types(channel), ['subscribe', 'unsubscribe']); await expectLater( client.connect(Uri.parse('ws://example.test/connect')), throwsStateError, ); }); test('a missing endpoint is not replaced by a guessed connection', () async { final channel = FakeChannel(); final client = PipelinesClient(channelFactory: (_) => channel); final session = AppSession(endpoint: null, client: client); addTearDown(session.dispose); await session.start(); await flush(); expect(channel.outgoing, isEmpty); expect(session.connected, isFalse); }); }