blob: d8124767fe7706c343a43955ac8c0a43e0769fb4 [file] [log] [blame]
// Copyright (c) 2019, 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.
// VMOptions=--timeline_streams=Dart
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:math';
import 'dart:typed_data';
import 'package:test/test.dart';
import 'package:vm_service/vm_service.dart';
import 'common/test_helper.dart';
final rng = Random();
// Enable to test redirects.
const shouldTestRedirects = false;
const maxRequestDelayMs = 3000;
const maxResponseDelayMs = 500;
const serverShutdownDelayMs = 2000;
void randomlyAddCookie(HttpResponse response) {
if (rng.nextInt(3) == 0) {
response.cookies.add(Cookie('Cookie-Monster', 'Me-want-cookie!'));
}
}
Future<bool> randomlyRedirect(HttpServer server, HttpResponse response) async {
if (shouldTestRedirects && rng.nextInt(5) == 0) {
final redirectUri = Uri(host: 'www.google.com', port: 80);
await response.redirect(redirectUri);
return true;
}
return false;
}
// Execute HTTP requests with random delays so requests have some overlap. This
// way we can be certain that timeline events are matching up properly even when
// connections are interrupted or can't be established.
Future<void> executeWithRandomDelay(Function f) =>
Future<void>.delayed(Duration(milliseconds: rng.nextInt(maxRequestDelayMs)))
.then((_) async {
try {
await f();
} on HttpException catch (_) {} on SocketException catch (_) {} on StateError catch (_) {} on OSError catch (_) {}
});
Uri randomlyAddRequestParams(Uri uri) {
const possiblePathSegments = <String>['foo', 'bar', 'baz', 'foobar'];
final segmentSubset =
possiblePathSegments.sublist(0, rng.nextInt(possiblePathSegments.length));
uri = uri.replace(pathSegments: segmentSubset);
if (rng.nextInt(3) == 0) {
uri = uri.replace(queryParameters: {
'foo': 'bar',
'year': '2019',
});
}
return uri;
}
Future<HttpServer> startServer() async {
final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
server.listen((request) async {
final response = request.response;
response.write(request.method);
randomlyAddCookie(response);
if (await randomlyRedirect(server, response)) {
// Redirect calls close() on the response.
return;
}
// Randomly delay response.
await Future.delayed(
Duration(milliseconds: rng.nextInt(maxResponseDelayMs)));
await response.close();
});
return server;
}
Future<void> testMain() async {
final server = await startServer();
HttpClient.enableTimelineLogging = true;
final client = HttpClient();
final requests = <Future>[];
final address =
Uri(scheme: 'http', host: server.address.host, port: server.port);
// HTTP DELETE
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.deleteUrl(randomlyAddRequestParams(address));
final string = 'DELETE $address';
r.headers.add(HttpHeaders.contentLengthHeader, string.length);
r.write(string);
final response = await r.close();
response.listen((_) {});
});
requests.add(future);
}
// HTTP GET
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.getUrl(randomlyAddRequestParams(address));
r.headers.add('cookie-eater', 'Cookie-Monster !');
final response = await r.close();
await response.drain();
});
requests.add(future);
}
// HTTP HEAD
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.headUrl(randomlyAddRequestParams(address));
await r.close();
});
requests.add(future);
}
// HTTP CONNECT
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r =
await client.openUrl('connect', randomlyAddRequestParams(address));
await r.close();
});
requests.add(future);
}
// HTTP PATCH
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.patchUrl(randomlyAddRequestParams(address));
final response = await r.close();
response.listen(null);
});
requests.add(future);
}
// HTTP POST
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.postUrl(randomlyAddRequestParams(address));
r.add(Uint8List.fromList([0, 1, 2]));
await r.close();
});
requests.add(future);
}
// HTTP PUT
for (int i = 0; i < 10; ++i) {
final future = executeWithRandomDelay(() async {
final r = await client.putUrl(randomlyAddRequestParams(address));
await r.close();
});
requests.add(future);
}
// Purposefully close server before some connections can be made to ensure
// that refused / interrupted connections correctly create finish timeline
// events.
await Future.delayed(Duration(milliseconds: serverShutdownDelayMs));
await server.close();
// Ensure all requests complete before finishing.
await Future.wait(requests);
}
late VmService vmService;
Future<void> hasValidHttpRequests(HttpProfile profile, String method) async {
final requests = profile.requests
.where(
(element) => element.method == method,
)
.toList();
expect(requests.length, 10);
for (final r in requests) {
final fullRequest =
await vmService.getHttpProfileRequest(r.isolateId, r.id);
if (r.isRequestComplete) {
final requestData = fullRequest.request!;
if (r.request!.hasError) {
void expectThrows(Function f) {
try {
f();
fail('Excepted exception');
} on HttpProfileRequestError {
// Expected.
}
}
expect(requestData.error, isNotNull);
expect(requestData.error!.isNotEmpty, true);
// Some data is available even if a request errored out.
expect(requestData.events.length, greaterThanOrEqualTo(0));
expect(fullRequest.requestBody!.length, greaterThanOrEqualTo(0));
// Accessing the following properties should cause an exception for
// requests which have encountered an error.
expectThrows(() => requestData.contentLength);
expectThrows(() => requestData.cookies);
expectThrows(() => requestData.followRedirects);
expectThrows(() => requestData.headers);
expectThrows(() => requestData.maxRedirects);
expectThrows(() => requestData.method);
expectThrows(() => requestData.persistentConnection);
} else {
// Invoke all non-nullable getters to ensure each is present in the JSON
// response.
requestData.connectionInfo;
requestData.contentLength;
requestData.cookies;
requestData.headers;
expect(requestData.maxRedirects, greaterThanOrEqualTo(0));
requestData.persistentConnection;
// If proxyInfo is non-null, uri and port _must_ be non-null.
if (requestData.proxyDetails != null) {
final proxyInfo = requestData.proxyDetails!;
expect(proxyInfo.host, true);
expect(proxyInfo.port, true);
}
// Check body of request has been sent and recorded correctly.
if (method == 'DELETE' || method == 'POST') {
if (method == 'POST') {
// add() was used
expect(
<int>[0, 1, 2],
fullRequest.requestBody!,
);
} else {
// write() was used.
expect(
utf8.decode(fullRequest.requestBody!).startsWith('$method http'),
true,
);
}
}
if (r.isResponseComplete) {
final responseData = r.response!;
expect(responseData.statusCode, greaterThanOrEqualTo(100));
expect(responseData.endTime, isNotNull);
expect(responseData.startTime > r.endTime!, true);
expect(responseData.endTime! >= responseData.startTime, true);
expect(utf8.decode(fullRequest.responseBody!), method);
responseData.headers;
responseData.compressionState;
responseData.connectionInfo;
responseData.contentLength;
responseData.cookies;
responseData.isRedirect;
responseData.persistentConnection;
responseData.reasonPhrase;
responseData.redirects;
expect(responseData.hasError, false);
expect(responseData.error, null);
}
}
}
}
}
void hasValidHttpProfile(HttpProfile profile, String method) {
expect(profile.requests.where((e) => e.method == method).length, 10);
}
Future<void> hasValidHttpCONNECTs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'CONNECT');
Future<void> hasValidHttpDELETEs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'DELETE');
Future<void> hasValidHttpGETs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'GET');
Future<void> hasValidHttpHEADs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'HEAD');
Future<void> hasValidHttpPATCHs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'PATCH');
Future<void> hasValidHttpPOSTs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'POST');
Future<void> hasValidHttpPUTs(HttpProfile profile) =>
hasValidHttpRequests(profile, 'PUT');
void hasDefaultRequestHeaders(HttpProfile profile) {
for(final request in profile.requests) {
if(!request.request!.hasError) {
expect(request.request?.headers['host'], isNotNull);
expect(request.request?.headers['user-agent'], isNotNull);
}
}
}
void hasCustomRequestHeaders(HttpProfile profile) {
var requests = profile.requests.where((e) => e.method == "GET").toList();
for(final request in requests) {
if(!request.request!.hasError) {
expect(request.request?.headers['cookie-eater'], isNotNull);
}
}
}
var tests = <IsolateTest>[
(VmService service, IsolateRef isolateRef) async {
vmService = service;
final isolateId = isolateRef.id!;
final httpProfile = await service.getHttpProfile(isolateId);
expect(httpProfile.requests.length, 70);
// Verify timeline events.
await hasValidHttpCONNECTs(httpProfile);
await hasValidHttpDELETEs(httpProfile);
await hasValidHttpGETs(httpProfile);
await hasValidHttpHEADs(httpProfile);
await hasValidHttpPATCHs(httpProfile);
await hasValidHttpPOSTs(httpProfile);
await hasValidHttpPUTs(httpProfile);
hasDefaultRequestHeaders(httpProfile);
hasCustomRequestHeaders(httpProfile);
},
];
main(args) async => runIsolateTests(
args,
tests,
'get_http_profile_test.dart',
testeeBefore: testMain,
);