9551eceaed
Remove obsolete control-family flags and icon metadata across all callers, dead alternate themes and host helpers, obsolete test setup, and the unused icon-font dependency. Preserve native Material Back transitions. Make navigation fixtures independent of update plugins and answer auxiliary shell snapshots so the complete application suite can run deterministically.
371 lines
12 KiB
Dart
371 lines
12 KiB
Dart
import 'dart:convert';
|
|
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import '../features/runs/ui/run_detail_finders.dart';
|
|
import '../native_back.dart';
|
|
import 'package:pipelines_app/application/app_route.dart';
|
|
import 'package:pipelines_app/application/app_router.dart';
|
|
import 'package:pipelines_app/application/pipelines_app.dart';
|
|
import 'package:pipelines_app/application/server_endpoint.dart';
|
|
import 'package:pipelines_app/core/transport/pipelines_client.dart';
|
|
import 'package:pipelines_app/features/pipelines/screen.dart';
|
|
|
|
import '../core/transport/pipelines_client_test.dart' show FakeChannel;
|
|
import '../features/pipelines/fixtures.dart';
|
|
import 'pipelines_replies.dart';
|
|
|
|
ServerEndpoint webServer() => ServerEndpoint.resolve(
|
|
base: Uri.parse('http://127.0.0.1:8096/'),
|
|
web: true,
|
|
);
|
|
|
|
Map<String, dynamic>? requestOf(FakeChannel channel, String type) => channel
|
|
.outgoing
|
|
.map((frame) => jsonDecode(frame as String) as Map<String, dynamic>)
|
|
.where((frame) => frame['type'] == type)
|
|
.firstOrNull;
|
|
|
|
Future<void> pumpApp(
|
|
WidgetTester tester, {
|
|
required FakeChannel channel,
|
|
required PipelinesClient client,
|
|
required PlatformRouteInformationProvider provider,
|
|
}) async {
|
|
await tester.pumpWidget(
|
|
PipelinesApp(
|
|
server: webServer(),
|
|
client: client,
|
|
// Navigation fixtures do not exercise native update plugins.
|
|
androidSupported: false,
|
|
routeInformationProvider: provider,
|
|
),
|
|
);
|
|
await tester.pump();
|
|
}
|
|
|
|
Future<void> replyList(
|
|
WidgetTester tester,
|
|
FakeChannel channel, {
|
|
required List<Map<String, dynamic>> runs,
|
|
}) async {
|
|
for (
|
|
var attempt = 0;
|
|
attempt < 40 && requestOf(channel, 'list_runs') == null;
|
|
attempt++
|
|
) {
|
|
await tester.pump(const Duration(milliseconds: 5));
|
|
}
|
|
final request = requestOf(channel, 'list_runs')!;
|
|
channel.incoming.add(
|
|
jsonEncode({'id': request['id'], 'type': 'runs', 'runs': runs}),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump();
|
|
}
|
|
|
|
Future<void> replyDetail(
|
|
WidgetTester tester,
|
|
FakeChannel channel,
|
|
num id,
|
|
) async {
|
|
for (
|
|
var attempt = 0;
|
|
attempt < 40 && requestOf(channel, 'get_run') == null;
|
|
attempt++
|
|
) {
|
|
await tester.pump(const Duration(milliseconds: 5));
|
|
}
|
|
final request = requestOf(channel, 'get_run')!;
|
|
expect(request['run_id'], id);
|
|
channel.incoming.add(
|
|
jsonEncode({
|
|
'id': request['id'],
|
|
'type': 'run',
|
|
'run_detail': {'id': id, 'title': 'Run $id', 'status': 'running'},
|
|
}),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump();
|
|
}
|
|
|
|
/// A run whose plan visits are deliberately not in sequence order, so a route
|
|
/// visit index must follow the recorded sequence, not the reply's row order.
|
|
Future<void> replyVisitDetail(
|
|
WidgetTester tester,
|
|
FakeChannel channel,
|
|
num id,
|
|
) async {
|
|
for (
|
|
var attempt = 0;
|
|
attempt < 40 && requestOf(channel, 'get_run') == null;
|
|
attempt++
|
|
) {
|
|
await tester.pump(const Duration(milliseconds: 5));
|
|
}
|
|
final request = requestOf(channel, 'get_run')!;
|
|
expect(request['run_id'], id);
|
|
channel.incoming.add(
|
|
jsonEncode({
|
|
'id': request['id'],
|
|
'type': 'run',
|
|
'run_detail': {
|
|
'id': id,
|
|
'title': 'Deep link run',
|
|
'name': 'release',
|
|
'status': 'succeeded',
|
|
'graph': {
|
|
'stages': [
|
|
{
|
|
'key': 'plan',
|
|
'type': 'model',
|
|
'edges': {'success': 'build'},
|
|
},
|
|
{
|
|
'key': 'build',
|
|
'type': 'model',
|
|
'edges': {'success': '#success'},
|
|
},
|
|
],
|
|
},
|
|
'steps': [
|
|
{'stage': 'plan', 'sequence': 5, 'status': 'completed'},
|
|
{'stage': 'build', 'sequence': 2, 'status': 'completed'},
|
|
{'stage': 'plan', 'sequence': 1, 'status': 'completed'},
|
|
],
|
|
},
|
|
}),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump();
|
|
}
|
|
|
|
void main() {
|
|
testWidgets('a /runs/1 boot link opens that run and Back returns to /runs', (
|
|
tester,
|
|
) async {
|
|
tester.view.physicalSize = const Size(390, 844);
|
|
tester.view.devicePixelRatio = 1;
|
|
addTearDown(tester.view.reset);
|
|
final channel = FakeChannel()..readyCompleter.complete();
|
|
final client = PipelinesClient(channelFactory: (_) => channel);
|
|
final provider = PlatformRouteInformationProvider(
|
|
initialRouteInformation: RouteInformation(uri: Uri.parse('/runs/1')),
|
|
);
|
|
addTearDown(provider.dispose);
|
|
|
|
await pumpApp(tester, channel: channel, client: client, provider: provider);
|
|
await replyList(
|
|
tester,
|
|
channel,
|
|
runs: [
|
|
{'id': 1, 'name': 'Deep-linked run', 'status': 'running'},
|
|
],
|
|
);
|
|
await replyDetail(tester, channel, 1);
|
|
await tester.pumpAndSettle();
|
|
|
|
expect(find.text('Run 1'), findsWidgets);
|
|
expect(findNativeBack(), findsOneWidget);
|
|
expect(provider.value.uri.path, '/runs/1');
|
|
expect(find.text('Pipelines — Not implemented'), findsNothing);
|
|
|
|
await tester.tap(findNativeBack());
|
|
await tester.pumpAndSettle();
|
|
expect(provider.value.uri.path, '/runs');
|
|
expect(find.text('Deep-linked run'), findsWidgets);
|
|
});
|
|
|
|
testWidgets('Android Back on a wide screen run is left to the platform', (
|
|
tester,
|
|
) async {
|
|
tester.view.physicalSize = const Size(1000, 800);
|
|
tester.view.devicePixelRatio = 1;
|
|
addTearDown(tester.view.reset);
|
|
final exits = <String>[];
|
|
tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
|
|
SystemChannels.platform,
|
|
(call) async {
|
|
if (call.method == 'SystemNavigator.pop') exits.add(call.method);
|
|
return null;
|
|
},
|
|
);
|
|
addTearDown(
|
|
() => tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
|
|
SystemChannels.platform,
|
|
null,
|
|
),
|
|
);
|
|
final channel = FakeChannel()..readyCompleter.complete();
|
|
final client = PipelinesClient(channelFactory: (_) => channel);
|
|
final provider = PlatformRouteInformationProvider(
|
|
initialRouteInformation: RouteInformation(uri: Uri.parse('/runs/1')),
|
|
);
|
|
addTearDown(provider.dispose);
|
|
await pumpApp(tester, channel: channel, client: client, provider: provider);
|
|
await replyList(
|
|
tester,
|
|
channel,
|
|
runs: [
|
|
{'id': 1, 'name': 'Deep-linked run', 'status': 'running'},
|
|
],
|
|
);
|
|
await replyDetail(tester, channel, 1);
|
|
expect(provider.value.uri.path, '/runs/1');
|
|
|
|
// A wide run sits in its tab, not on a pushed page, and the app adds no
|
|
// Back behavior: the system Back is the platform's at once.
|
|
await tester.binding.handlePopRoute();
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Press back again to close'), findsNothing);
|
|
expect(exits, ['SystemNavigator.pop']);
|
|
expect(provider.value.uri.path, '/runs/1');
|
|
});
|
|
|
|
testWidgets('tabs and run selection update the route; browser Back pops it', (
|
|
tester,
|
|
) async {
|
|
final channel = FakeChannel()..readyCompleter.complete();
|
|
final client = PipelinesClient(channelFactory: (_) => channel);
|
|
final provider = PlatformRouteInformationProvider(
|
|
initialRouteInformation: RouteInformation(uri: Uri.parse('/pipelines')),
|
|
);
|
|
addTearDown(provider.dispose);
|
|
|
|
await pumpApp(tester, channel: channel, client: client, provider: provider);
|
|
expect(provider.value.uri.path, '/pipelines');
|
|
final fixture = PipelineFixture();
|
|
await replyPipelines(tester, channel, fixture);
|
|
final pipelinesRunsId =
|
|
pipelineRequest(channel, 'list_runs')!['id'] as String;
|
|
|
|
// The terminal's bar button belongs to the Chat tab only.
|
|
const terminalButton = ValueKey('shell.terminal');
|
|
expect(find.byKey(terminalButton), findsNothing);
|
|
|
|
await tester.tap(find.byKey(const ValueKey('shell.destination.runs')));
|
|
await tester.pump();
|
|
expect(provider.value.uri.path, '/runs');
|
|
expect(find.byKey(terminalButton), findsNothing);
|
|
|
|
final runsRequest = await waitForLaterRequest(
|
|
tester,
|
|
channel,
|
|
'list_runs',
|
|
pipelinesRunsId,
|
|
);
|
|
channel.incoming.add(
|
|
jsonEncode({
|
|
'id': runsRequest['id'],
|
|
'type': 'runs',
|
|
'runs': [
|
|
{'id': 2, 'name': 'Beta run', 'status': 'failed'},
|
|
],
|
|
}),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump();
|
|
await tester.tap(find.text('Beta run'));
|
|
await tester.pump();
|
|
expect(provider.value.uri.path, '/runs/2');
|
|
await replyDetail(tester, channel, 2);
|
|
expect(findNativeBack(), findsNothing);
|
|
expect(find.byKey(const ValueKey('run-detail-pane')), findsOneWidget);
|
|
|
|
// The engine's browser Back arrives as new route information.
|
|
await provider.didPushRouteInformation(
|
|
RouteInformation(uri: Uri.parse('/runs')),
|
|
);
|
|
await tester.pump();
|
|
// The bar returns to the tab's own after the closed run hands it back.
|
|
await tester.pump();
|
|
expect(find.text('Beta run'), findsWidgets);
|
|
expect(findNativeBack(), findsNothing);
|
|
|
|
// Forward re-opens the same run.
|
|
await provider.didPushRouteInformation(
|
|
RouteInformation(uri: Uri.parse('/runs/2')),
|
|
);
|
|
await tester.pump();
|
|
await replyDetail(tester, channel, 2);
|
|
await tester.pump();
|
|
expect(findNativeBack(), findsNothing);
|
|
expect(find.byKey(const ValueKey('run-detail-pane')), findsOneWidget);
|
|
|
|
await tester.tap(find.byKey(const ValueKey('shell.destination.chat')));
|
|
await tester.pump();
|
|
await tester.pump();
|
|
expect(provider.value.uri.path, startsWith('/chat'));
|
|
expect(find.byKey(terminalButton), findsOneWidget);
|
|
});
|
|
|
|
testWidgets('a malformed boot path is corrected to /pipelines', (
|
|
tester,
|
|
) async {
|
|
final channel = FakeChannel()..readyCompleter.complete();
|
|
final client = PipelinesClient(channelFactory: (_) => channel);
|
|
final provider = PlatformRouteInformationProvider(
|
|
initialRouteInformation: RouteInformation(uri: Uri.parse('/runs/abc')),
|
|
);
|
|
addTearDown(provider.dispose);
|
|
|
|
await pumpApp(tester, channel: channel, client: client, provider: provider);
|
|
expect(provider.value.uri.path, '/pipelines');
|
|
await replyPipelines(tester, channel, PipelineFixture());
|
|
expect(find.byType(PipelinesScreen), findsOneWidget);
|
|
expect(find.text('Pipelines — Not implemented'), findsNothing);
|
|
await tester.pumpWidget(const SizedBox.shrink());
|
|
await tester.pump();
|
|
});
|
|
|
|
testWidgets('a queried stage boot link opens that exact recorded visit', (
|
|
tester,
|
|
) async {
|
|
final channel = FakeChannel()..readyCompleter.complete();
|
|
final client = PipelinesClient(channelFactory: (_) => channel);
|
|
final provider = PlatformRouteInformationProvider(
|
|
initialRouteInformation: RouteInformation(
|
|
uri: Uri.parse('/runs/77/stage/plan?visit=0'),
|
|
),
|
|
);
|
|
addTearDown(provider.dispose);
|
|
|
|
await pumpApp(tester, channel: channel, client: client, provider: provider);
|
|
await replyList(
|
|
tester,
|
|
channel,
|
|
runs: [
|
|
{'id': 77, 'name': 'Deep link run', 'status': 'succeeded'},
|
|
],
|
|
);
|
|
await replyVisitDetail(tester, channel, 77);
|
|
// The visit opens as its own page once the detail has drawn.
|
|
await tester.pump();
|
|
await tester.pump(const Duration(milliseconds: 400));
|
|
await tester.pump(const Duration(milliseconds: 400));
|
|
|
|
// The query reached the detail: visit 0 is the earlier plan visit (seq 1),
|
|
// not the latest one the pane would show without a visit.
|
|
expect(find.byKey(const Key('run-visit-pane')), findsOneWidget);
|
|
expectVisitHeading(tester, 'plan', 1);
|
|
expect(find.text('Visit 5'), findsNothing);
|
|
expect(provider.value.uri.toString(), '/runs/77/stage/plan?visit=0');
|
|
|
|
// A history entry the app itself writes is parsed back as a query, so
|
|
// Back/Forward (and a reload) open the visit instead of a bogus stage key.
|
|
final restored = const AppRouteParser()
|
|
.restoreRouteInformation(AppRoute.run.stage(77, 'plan', visit: 1))
|
|
.uri;
|
|
expect(restored.toString(), '/runs/77/stage/plan?visit=1');
|
|
await provider.didPushRouteInformation(RouteInformation(uri: restored));
|
|
await tester.pump();
|
|
await tester.pump();
|
|
await tester.pump(const Duration(milliseconds: 400));
|
|
await tester.pump(const Duration(milliseconds: 400));
|
|
expectVisitHeading(tester, 'plan', 2);
|
|
expect(provider.value.uri.path, '/runs/77/stage/plan');
|
|
expect(provider.value.uri.query, 'visit=1');
|
|
});
|
|
}
|