Add an integration test for the Network screen (#9003)

There's a lot to this change!

I wanted precise control over when the "test app" makes requests, and what kind, etc. I've added a capability for a Dart test app to print out what port it's "control server" is listening to, very similar to how it prints out the URL for DevTools to connect to.

The "control server" is a basic HTTP server, that can be controlled with very simple requests. In this case, when the server sees a request to '/get/', it calls a dart:io HttpClient to send an HTTP GET request. A request to '/post/' directs the HttpClient to send an HTTP POST request, etc.

For the network screen tests to see complete requests, there is a second HTTP server that responds to the test requests.

So some changes are made to TestDartCliApp to support the "control port". This int is then passed to the integration test in the 'test args' (see the changes to integration_test/test_infra/run/run_test.dart).

OK, then the test itself: This test is simple for now. The following types of requests are validated:

* dart:io HttpClient GET
* dart:io HttpClient POST
* dart:io HttpClient PUT
* dart:io HttpClient DELETE
* Dio GET
* Dio POST

There are some TODOs for other requests we want to validate.

Work towards #7554.

Author: srawlins

packages/devtools_app/integration_test/test/live_connection/network_screen_test.dart

@@ -0,0 +1,109 @@
+// Copyright 2025 The Flutter Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file or at https://developers.google.com/open-source/licenses/bsd.
+
+// Do not delete these arguments. They are parsed by test runner.
+// test-argument:appPath="test/test_infra/fixtures/networking_app/bin/main.dart"
+
+import 'package:devtools_app/devtools_app.dart';
+import 'package:devtools_app/src/shared/table/table.dart' show DevToolsTable;
+import 'package:devtools_test/helpers.dart';
+import 'package:devtools_test/integration_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:http/http.dart' as http;
+import 'package:integration_test/integration_test.dart';
+
+// To run:
+// dart run integration_test/run_tests.dart --target=integration_test/test/live_connection/network_screen_test.dart --test-app-device=cli
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+
+  late TestApp testApp;
+
+  setUpAll(() {
+    testApp = TestApp.fromEnvironment();
+    expect(testApp.vmServiceUri, isNotNull);
+  });
+
+  tearDown(() async {
+    await resetHistory();
+    await http.get(Uri.parse('http://localhost:${testApp.controlPort}/exit/'));
+  });
+
+  testWidgets('nnn', (tester) async {
+    await pumpAndConnectDevTools(tester, testApp);
+    await _prepareNetworkScreen(tester);
+
+    final helper = _NetworkScreenHelper(tester, testApp.controlPort!);
+
+    // Instruct the app to make a GET request via the dart:io HttpClient.
+    await helper.triggerRequest('get/');
+    _expectInRequestTable('GET');
+    await helper.clear();
+
+    // Instruct the app to make a POST request via the dart:io HttpClient.
+    await helper.triggerRequest('post/');
+    _expectInRequestTable('POST');
+    await helper.clear();
+
+    // Instruct the app to make a PUT request via the dart:io HttpClient.
+    await helper.triggerRequest('put/');
+    _expectInRequestTable('PUT');
+    await helper.clear();
+
+    // Instruct the app to make a DELETE request via the dart:io HttpClient.
+    await helper.triggerRequest('delete/');
+    _expectInRequestTable('DELETE');
+    await helper.clear();
+
+    // Instruct the app to make a GET request via Dio.
+    await helper.triggerRequest('dio/get/');
+    _expectInRequestTable('GET');
+    await helper.clear();
+
+    // Instruct the app to make a POST request via Dio.
+    await helper.triggerRequest('dio/post/');
+    _expectInRequestTable('POST');
+  });
+}
+
+final class _NetworkScreenHelper {
+  _NetworkScreenHelper(this._tester, this._controlPort);
+
+  final WidgetTester _tester;
+
+  final int _controlPort;
+
+  Future<void> clear() async {
+    // Press the 'Clear' button between tests.
+    await _tester.tap(find.text('Clear'));
+    await _tester.pump(safePumpDuration);
+  }
+
+  Future<void> triggerRequest(String path) async {
+    await http.get(Uri.parse('http://localhost:$_controlPort/$path'));
+    await Future.delayed(const Duration(milliseconds: 200));
+    await _tester.pump(safePumpDuration);
+  }
+}
+
+void _expectInRequestTable(String text) {
+  expect(
+    find.descendant(
+      of: find.byType(DevToolsTable<NetworkRequest>),
+      matching: find.text(text),
+    ),
+    findsOneWidget,
+  );
+}
+
+/// Prepares the UI of the network screen for an integration test.
+Future<void> _prepareNetworkScreen(WidgetTester tester) async {
+  await switchToScreen(
+    tester,
+    tabIcon: ScreenMetaData.network.icon,
+    tabIconAsset: ScreenMetaData.network.iconAsset,
+    screenId: ScreenMetaData.network.id,
+  );
+}

packages/devtools_app/integration_test/test_infra/run/_test_app_driver.dart

@@ -39,25 +39,23 @@ class TestFlutterApp extends IntegrationTestApp {
   Future<void> waitForAppStart() async {
     // Set this up now, but we don't await it yet. We want to make sure we don't
     // miss it while waiting for debugPort below.
-    final started = waitFor(
+    final started = _waitFor(
       event: FlutterDaemonConstants.appStartedKey,
       timeout: IntegrationTestApp._appStartTimeout,
     );
 
-    final debugPort = await waitFor(
+    final debugPort = await _waitFor(
       event: FlutterDaemonConstants.appDebugPortKey,
       timeout: IntegrationTestApp._appStartTimeout,
     );
     final wsUriString =
         (debugPort[FlutterDaemonConstants.paramsKey]!
                 as Map<String, Object?>)[FlutterDaemonConstants.wsUriKey]
             as String;
-    _vmServiceWsUri = Uri.parse(wsUriString);
+    final vmServiceWsUri = Uri.parse(wsUriString);
 
     // Map to WS URI.
-    _vmServiceWsUri = convertToWebSocketUrl(
-      serviceProtocolUrl: _vmServiceWsUri,
-    );
+    _vmServiceWsUri = convertToWebSocketUrl(serviceProtocolUrl: vmServiceWsUri);
 
     // Now await the started event; if it had already happened the future will
     // have already completed.
@@ -101,7 +99,7 @@ class TestFlutterApp extends IntegrationTestApp {
     // Set up the response future before we send the request to avoid any
     // races. If the method we're calling is app.stop then we tell waitFor not
     // to throw if it sees an app.stop event before the response to this request.
-    final responseFuture = waitFor(
+    final responseFuture = _waitFor(
       id: requestId,
       ignoreAppStopEvent: method == 'app.stop',
     );
@@ -113,7 +111,7 @@ class TestFlutterApp extends IntegrationTestApp {
     }
   }
 
-  Future<Map<String, Object?>> waitFor({
+  Future<Map<String, Object?>> _waitFor({
     String? event,
     int? id,
     Duration? timeout,
@@ -199,6 +197,10 @@ class TestDartCliApp extends IntegrationTestApp {
     : super(appPath, TestAppDevice.cli);
 
   static const vmServicePrefix = 'The Dart VM service is listening on ';
+  static const controlPortKey = 'controlPort';
+
+  int? get controlPort => _controlPort;
+  late final int? _controlPort;
 
   @override
   Future<void> startProcess() async {
@@ -215,20 +217,32 @@ class TestDartCliApp extends IntegrationTestApp {
 
   @override
   Future<void> waitForAppStart() async {
-    final vmServiceUri = await waitFor(
+    final vmServiceUriString = await _waitFor(
       message: vmServicePrefix,
       timeout: IntegrationTestApp._appStartTimeout,
     );
-    final parsedVmServiceUri = Uri.parse(vmServiceUri);
+    final vmServiceUri = Uri.parse(vmServiceUriString);
+    _controlPort = await _waitFor(
+      message: controlPortKey,
+      timeout: const Duration(seconds: 1),
+      optional: true,
+    );
 
     // Map to WS URI.
-    _vmServiceWsUri = convertToWebSocketUrl(
-      serviceProtocolUrl: parsedVmServiceUri,
-    );
+    _vmServiceWsUri = convertToWebSocketUrl(serviceProtocolUrl: vmServiceUri);
   }
 
-  Future<String> waitFor({required String message, Duration? timeout}) {
-    final response = Completer<String>();
+  /// Waits for [message] to appear on stdout.
+  ///
+  /// After [timeout], if no such message has appeared, then either `null` is
+  /// returned, if [optional] is `true`, or an exception is thrown, if
+  /// [optional] is `false`.
+  Future<T> _waitFor<T>({
+    required String message,
+    Duration? timeout,
+    bool optional = false,
+  }) {
+    final response = Completer<T>();
     late StreamSubscription<String> sub;
     sub = stdoutController.stream.listen(
       (String line) => _handleStdout(
@@ -239,25 +253,38 @@ class TestDartCliApp extends IntegrationTestApp {
       ),
     );
 
-    return _timeoutWithMessages<String>(
+    if (optional) {
+      return response.future
+          .timeout(
+            timeout ?? IntegrationTestApp._defaultTimeout,
+            onTimeout: () => null as T,
+          )
+          .whenComplete(() => sub.cancel());
+    }
+
+    return _timeoutWithMessages<T>(
       () => response.future,
       timeout: timeout,
       message: 'Did not receive expected message: $message.',
     ).whenComplete(() => sub.cancel());
   }
 
-  void _handleStdout(
+  void _handleStdout<T>(
     String line, {
     required StreamSubscription<String> subscription,
-    required Completer<String> response,
+    required Completer<T> response,
     required String message,
   }) async {
     if (message == vmServicePrefix && line.startsWith(vmServicePrefix)) {
       final vmServiceUri = line.substring(
         line.indexOf(vmServicePrefix) + vmServicePrefix.length,
       );
       await subscription.cancel();
-      response.complete(vmServiceUri);
+      response.complete(vmServiceUri as T);
+    } else if (message == controlPortKey && line.contains(controlPortKey)) {
+      final asJson = jsonDecode(line) as Map;
+      await subscription.cancel();
+      response.complete(asJson[controlPortKey] as T);
     }
   }
 }
@@ -286,7 +313,7 @@ abstract class IntegrationTestApp with IOMixin {
   final _allMessages = StreamController<String>.broadcast();
 
   Uri get vmServiceUri => _vmServiceWsUri;
-  late Uri _vmServiceWsUri;
+  late final Uri _vmServiceWsUri;
 
   Future<void> startProcess();
 
@@ -416,9 +443,10 @@ enum TestAppDevice {
 
   /// A mapping of test app device to the unsupported tests for that device.
   static final _unsupportedTestsForDevice = <TestAppDevice, List<String>>{
-    TestAppDevice.flutterTester: [],
+    TestAppDevice.flutterTester: ['network_screen_test.dart'],
     TestAppDevice.flutterChrome: [
       'eval_and_browse_test.dart',
+      'network_screen_test.dart',
       'perfetto_test.dart',
       'performance_screen_event_recording_test.dart',
       'service_connection_test.dart',

packages/devtools_app/integration_test/test_infra/run/run_test.dart

@@ -58,7 +58,10 @@ Future<void> runFlutterIntegrationTest(
   // Run the flutter integration test.
   final testRunner = IntegrationTestRunner();
   try {
-    final testArgs = <String, Object>{if (!offline) 'service_uri': testAppUri};
+    final testArgs = <String, Object?>{
+      if (!offline) 'service_uri': testAppUri,
+      if (testApp is TestDartCliApp) 'control_port': testApp.controlPort,
+    };
     final testTarget = testRunnerArgs.testTarget!;
     debugLog('starting test run for $testTarget');
     await testRunner.run(