Add browser tests for the response body. (#712)

Author: brianquinlan

pkgs/http_client_conformance_tests/lib/http_client_conformance_tests.dart

@@ -8,13 +8,15 @@ import 'src/redirect_tests.dart';
 import 'src/request_body_streamed_tests.dart';
 import 'src/request_body_tests.dart';
 import 'src/request_headers_tests.dart';
+import 'src/response_body_streamed_test.dart';
 import 'src/response_body_tests.dart';
 import 'src/response_headers_tests.dart';
 
 export 'src/redirect_tests.dart' show testRedirect;
 export 'src/request_body_streamed_tests.dart' show testRequestBodyStreamed;
 export 'src/request_body_tests.dart' show testRequestBody;
 export 'src/request_headers_tests.dart' show testRequestHeaders;
+export 'src/response_body_streamed_test.dart' show testResponseBodyStreamed;
 export 'src/response_body_tests.dart' show testResponseBody;
 export 'src/response_headers_tests.dart' show testResponseHeaders;
 
@@ -37,6 +39,8 @@ void testAll(Client client,
   testRequestBody(client);
   testRequestBodyStreamed(client, canStreamRequestBody: canStreamRequestBody);
   testResponseBody(client, canStreamResponseBody: canStreamResponseBody);
+  testResponseBodyStreamed(client,
+      canStreamResponseBody: canStreamResponseBody);
   testRequestHeaders(client);
   testResponseHeaders(client);
   testRedirect(client, redirectAlwaysAllowed: redirectAlwaysAllowed);

pkgs/http_client_conformance_tests/lib/src/response_body_server.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:stream_channel/stream_channel.dart';
+
+/// Starts an HTTP server that responds with "Hello World!"
+///
+/// Channel protocol:
+///    On Startup:
+///     - send port
+///    When Receive Anything:
+///     - exit
+void hybridMain(StreamChannel<Object?> channel) async {
+  final server = (await HttpServer.bind('localhost', 0))
+    ..listen((request) async {
+      await request.drain<void>();
+      request.response.headers.set('Access-Control-Allow-Origin', '*');
+      request.response.headers.set('Content-Type', 'text/plain');
+      request.response.write('Hello World!');
+      await request.response.close();
+    });
+
+  channel.sink.add(server.port);
+  await channel
+      .stream.first; // Any writes indicates that the server should exit.
+  unawaited(server.close());
+}

pkgs/http_client_conformance_tests/lib/src/response_body_streamed_server.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:async/async.dart';
+import 'package:stream_channel/stream_channel.dart';
+
+/// Starts an HTTP server that sends a stream of integers.
+///
+/// Channel protocol:
+///    On Startup:
+///     - send port
+///    When Receive Anything:
+///     - close current request
+///     - exit server
+void hybridMain(StreamChannel<Object?> channel) async {
+  final channelQueue = StreamQueue(channel.stream);
+  var serverWriting = true;
+
+  late HttpServer server;
+  server = (await HttpServer.bind('localhost', 0))
+    ..listen((request) async {
+      await request.drain<void>();
+      request.response.headers.set('Access-Control-Allow-Origin', '*');
+      request.response.headers.set('Content-Type', 'text/plain');
+      serverWriting = true;
+      for (var i = 0; serverWriting; ++i) {
+        request.response.write('$i\n');
+        await request.response.flush();
+        // Let the event loop run.
+        await Future(() {});
+      }
+      await request.response.close();
+      unawaited(server.close());
+    });
+
+  channel.sink.add(server.port);
+  unawaited(channelQueue.next.then((value) => serverWriting = false));
+}

pkgs/http_client_conformance_tests/lib/src/response_body_streamed_test.dart

@@ -0,0 +1,54 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:convert';
+
+import 'package:async/async.dart';
+import 'package:http/http.dart';
+import 'package:stream_channel/stream_channel.dart';
+import 'package:test/test.dart';
+
+/// Tests that the [Client] correctly implements HTTP responses with bodies of
+/// unbounded size.
+///
+/// If [canStreamResponseBody] is `false` then tests that assume that the
+/// [Client] supports receiving HTTP responses with unbounded body sizes will
+/// be skipped
+void testResponseBodyStreamed(Client client,
+    {bool canStreamResponseBody = true}) async {
+  group('streamed response body', () {
+    late final String host;
+    late final StreamChannel<Object?> httpServerChannel;
+    late final StreamQueue<Object?> httpServerQueue;
+
+    setUpAll(() async {
+      httpServerChannel =
+          spawnHybridUri('../lib/src/response_body_streamed_server.dart');
+      httpServerQueue = StreamQueue(httpServerChannel.stream);
+      host = 'localhost:${await httpServerQueue.next}';
+    });
+    tearDownAll(() => httpServerChannel.sink.add(null));
+
+    test('large response streamed without content length', () async {
+      // The server continuously streams data to the client until
+      // instructed to stop.
+      //
+      // This ensures that the client supports streamed responses.
+
+      final request = Request('GET', Uri.http(host, ''));
+      final response = await client.send(request);
+      var lastReceived = 0;
+      await const LineSplitter()
+          .bind(const Utf8Decoder().bind(response.stream))
+          .forEach((s) {
+        lastReceived = int.parse(s.trim());
+        if (lastReceived == 1000) {
+          httpServerChannel.sink.add(true);
+        }
+      });
+      expect(response.headers['content-type'], 'text/plain');
+      expect(lastReceived, greaterThanOrEqualTo(1000));
+    }, skip: canStreamResponseBody ? false : 'does not stream response bodies');
+  });
+}

pkgs/http_client_conformance_tests/lib/src/response_body_tests.dart

@@ -2,11 +2,9 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'dart:async';
-import 'dart:convert';
-import 'dart:io';
-
+import 'package:async/async.dart';
 import 'package:http/http.dart';
+import 'package:stream_channel/stream_channel.dart';
 import 'package:test/test.dart';
 
 /// Tests that the [Client] correctly implements HTTP responses with bodies.
@@ -17,78 +15,40 @@ import 'package:test/test.dart';
 void testResponseBody(Client client,
     {bool canStreamResponseBody = true}) async {
   group('response body', () {
+    late final String host;
+    late final StreamChannel<Object?> httpServerChannel;
+    late final StreamQueue<Object?> httpServerQueue;
+    const message = 'Hello World!';
+
+    setUpAll(() async {
+      httpServerChannel =
+          spawnHybridUri('../lib/src/response_body_server.dart');
+      httpServerQueue = StreamQueue(httpServerChannel.stream);
+      host = 'localhost:${await httpServerQueue.next}';
+    });
+    tearDownAll(() => httpServerChannel.sink.add(null));
+
     test('small response with content length', () async {
-      const message = 'Hello World!';
-      final server = (await HttpServer.bind('localhost', 0))
-        ..listen((request) async {
-          await request.drain<void>();
-          request.response.headers.set('Content-Type', 'text/plain');
-          request.response.write(message);
-          await request.response.close();
-        });
-      final response =
-          await client.get(Uri.http('localhost:${server.port}', ''));
+      final response = await client.get(Uri.http(host, ''));
       expect(response.body, message);
       expect(response.bodyBytes, message.codeUnits);
       expect(response.contentLength, message.length);
       expect(response.headers['content-type'], 'text/plain');
-      await server.close();
     });
 
     test('small response streamed without content length', () async {
-      const message = 'Hello World!';
-      final server = (await HttpServer.bind('localhost', 0))
-        ..listen((request) async {
-          await request.drain<void>();
-          request.response.headers.set('Content-Type', 'text/plain');
-          request.response.write(message);
-          await request.response.close();
-        });
-      final request = Request('GET', Uri.http('localhost:${server.port}', ''));
+      final request = Request('GET', Uri.http(host, ''));
       final response = await client.send(request);
       expect(await response.stream.bytesToString(), message);
-      expect(response.contentLength, null);
+      if (canStreamResponseBody) {
+        expect(response.contentLength, null);
+      } else {
+        // If the response body is small then the Client can emulate a streamed
+        // response without streaming. But `response.contentLength` may or
+        // may not be set.
+        expect(response.contentLength, isIn([null, 12]));
+      }
       expect(response.headers['content-type'], 'text/plain');
-      await server.close();
     });
-
-    test('large response streamed without content length', () async {
-      // The server continuously streams data to the client until
-      // instructed to stop (by setting `serverWriting` to `false`).
-      // The client sets `serverWriting` to `false` after it has
-      // already received some data.
-      //
-      // This ensures that the client supports streamed responses.
-      var serverWriting = false;
-      final server = (await HttpServer.bind('localhost', 0))
-        ..listen((request) async {
-          await request.drain<void>();
-          request.response.headers.set('Content-Type', 'text/plain');
-          serverWriting = true;
-          for (var i = 0; serverWriting; ++i) {
-            request.response.write('$i\n');
-            await request.response.flush();
-            // Let the event loop run.
-            await Future<void>.delayed(const Duration());
-          }
-          await request.response.close();
-        });
-      final request = Request('GET', Uri.http('localhost:${server.port}', ''));
-      final response = await client.send(request);
-      var lastReceived = 0;
-      await const LineSplitter()
-          .bind(const Utf8Decoder().bind(response.stream))
-          .forEach((s) {
-        lastReceived = int.parse(s.trim());
-        if (lastReceived < 1000) {
-          expect(serverWriting, true);
-        } else {
-          serverWriting = false;
-        }
-      });
-      expect(response.headers['content-type'], 'text/plain');
-      expect(lastReceived, greaterThanOrEqualTo(1000));
-      await server.close();
-    }, skip: canStreamResponseBody ? false : 'does not stream response bodies');
   });
 }

pkgs/http_client_conformance_tests/test/browser_client_test.dart

@@ -16,5 +16,7 @@ void main() {
     testRequestBody(client);
     testRedirect(client, redirectAlwaysAllowed: true);
     testRequestBodyStreamed(client, canStreamRequestBody: false);
+    testResponseBody(client, canStreamResponseBody: false);
+    testResponseBodyStreamed(client, canStreamResponseBody: false);
   });
 }