4ae2de444e
Pipelines and Runs no longer carry it; the keyboard shortcut still toggles the terminal everywhere.
370 lines
12 KiB
Dart
370 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,
|
|
cupertino: 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');
|
|
});
|
|
}
|