dev/bots/test/luci_resultdb_test.dart - mirrors/flutter - Git at Google

 // Copyright 2014 The Flutter Authors. 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 'dart:io';

 import 'package:file/memory.dart';

 import '../luci_resultdb.dart';
 import '../tool_subsharding.dart';
 import 'common.dart';

 const String _kMetrics = '''
 {"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}
 {"suite":{"id":0,"platform":"vm","path":"test/foo_test.dart"},"type":"suite","time":0}
 {"test":{"id":1,"name":"loading test/foo_test.dart","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":null,"column":null,"url":null},"type":"testStart","time":0}
 {"testID":1,"result":"success","skipped":false,"hidden":true,"type":"testDone","time":1}
 {"test":{"id":2,"name":"passing test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}
 {"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}
 {"test":{"id":3,"name":"failing test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":20,"column":3,"url":"file:///foo"},"type":"testStart","time":102}
 {"testID":3,"result":"failure","skipped":false,"hidden":false,"type":"testDone","time":152}
 {"test":{"id":4,"name":"skipped test","suiteID":0,"groupIDs":[],"metadata":{"skip":true,"skipReason":null},"line":30,"column":3,"url":"file:///foo"},"type":"testStart","time":152}
 {"testID":4,"result":"success","skipped":true,"hidden":false,"type":"testDone","time":152}
 {"success":false,"type":"done","time":200}''';

 TestFileReporterResults _parse() {
   final fileSystem = MemoryFileSystem.test();
   final File file = fileSystem.file('metrics');
   file.writeAsStringSync(_kMetrics);
   return TestFileReporterResults.fromFile(file);
 }

 String _caseName(LuciTestResult result) => result.testId.caseName;

 void main() {
   group('convertToLuciTestResultsFormat', () {
     test('converts each non-hidden test into a structured ResultDB TestResult', () {
       final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());

       // The hidden "loading ..." bookkeeping test is excluded.
       expect(results, hasLength(3));

       final byCase = <String, LuciTestResult>{
         for (final LuciTestResult r in results) _caseName(r): r,
       };

       expect(byCase.keys, containsAll(<String>['passing test', 'failing test', 'skipped test']));
       // The module name is the test file, and the scheme is the level-free
       // 'flat' scheme, so file and test name are separate columns in the UI.
       for (final LuciTestResult(
             testId: LuciStructuredTestId(:moduleName, :moduleScheme, :moduleVariant),
           )
           in results) {
         expect(moduleName, 'test/foo_test.dart');
         expect(moduleScheme, 'flat');
         expect(moduleVariant, <String, String>{});
       }
     });

     test('strips rootDirectory prefix from absolute suite paths', () {
       const metrics =
           '{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
           '{"suite":{"id":0,"platform":"vm","path":"/b/s/w/ir/x/w/flutter/dev/foo/bar_test.dart"},"type":"suite","time":0}\n'
           '{"test":{"id":2,"name":"my test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
           '{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
           '{"success":true,"type":"done","time":200}';
       final fileSystem = MemoryFileSystem.test();
       final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
       final parsed = TestFileReporterResults.fromFile(file);

       final List<LuciTestResult> stripped = convertToLuciTestResultsFormat(
         parsed,
         rootDirectory: '/b/s/w/ir/x/w/flutter',
       );
       final [LuciTestResult(testId: LuciStructuredTestId(:moduleName, :caseName))] = stripped;
       expect(moduleName, 'dev/foo/bar_test.dart');
       expect(caseName, 'my test');

       // Without a rootDirectory, the absolute path is preserved.
       final [
         LuciTestResult(testId: LuciStructuredTestId(moduleName: String unstrippedModuleName)),
       ] = convertToLuciTestResultsFormat(
         parsed,
       );
       expect(unstrippedModuleName, '/b/s/w/ir/x/w/flutter/dev/foo/bar_test.dart');
     });

     test('resolves relative suite paths against the working directory', () {
       const metrics =
           '{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
           '{"suite":{"id":0,"platform":"vm","path":"test/bar_test.dart"},"type":"suite","time":0}\n'
           '{"test":{"id":2,"name":"my test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
           '{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
           '{"success":true,"type":"done","time":200}';
       final fileSystem = MemoryFileSystem.test();
       final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
       final parsed = TestFileReporterResults.fromFile(file);

       // A `packages/flutter` shard reports suite paths relative to its working
       // directory; resolving against it yields a repo-relative module name.
       final List<LuciTestResult> results = convertToLuciTestResultsFormat(
         parsed,
         workingDirectory: '/b/s/w/ir/x/w/flutter/packages/flutter',
         rootDirectory: '/b/s/w/ir/x/w/flutter',
       );
       final [LuciTestResult(testId: LuciStructuredTestId(:moduleName))] = results;
       expect(moduleName, 'packages/flutter/test/bar_test.dart');
     });

     test('escapes colons and backslashes in the case name', () {
       const metrics =
           '{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
           '{"suite":{"id":0,"platform":"vm","path":"test/foo_test.dart"},"type":"suite","time":0}\n'
           '{"test":{"id":2,"name":"Group: sub\\\\path does x","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
           '{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
           '{"success":true,"type":"done","time":200}';
       final fileSystem = MemoryFileSystem.test();
       final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
       final parsed = TestFileReporterResults.fromFile(file);

       final List<LuciTestResult> results = convertToLuciTestResultsFormat(parsed);
       // The raw test name is `Group: sub\path does x`; ':' becomes '\:' and the
       // backslash becomes '\\'.
       final [LuciTestResult(testId: LuciStructuredTestId(:caseName))] = results;
       expect(caseName, r'Group\: sub\\path does x');
     });

     test('maps status and expectedness correctly', () {
       final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());
       final byId = <String, LuciTestResult>{
         for (final LuciTestResult r in results) _caseName(r): r,
       };

       final LuciTestResult pass = byId['passing test']!;
       expect((pass.status, pass.expected), ('PASS', true));

       final LuciTestResult fail = byId['failing test']!;
       expect((fail.status, fail.expected), ('FAIL', false));

       final LuciTestResult skip = byId['skipped test']!;
       expect((skip.status, skip.expected), ('SKIP', true));
     });

     test('marks failing tests as expected when expectFailure is true', () {
       final List<LuciTestResult> results = convertToLuciTestResultsFormat(
         _parse(),
         expectFailure: true,
       );
       final byId = <String, LuciTestResult>{
         for (final LuciTestResult r in results) _caseName(r): r,
       };

       // The failing test keeps its FAIL status but is now an *expected* failure,
       // so ResultDB won't surface it as a red regression (e.g. the
       // test_smoke_test negative tests run with expectFailure: true).
       final LuciTestResult fail = byId['failing test']!;
       expect((fail.status, fail.expected), ('FAIL', true));

       // Passing and skipped tests remain expected as well.
       expect(byId['passing test']!.expected, true);
       expect(byId['skipped test']!.expected, true);
     });

     test('emits a proto Duration string and unique result ids', () {
       final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());

       for (final r in results) {
         expect(r.duration, matches(r'^\d+\.\d+s$'));
       }
       final resultIds = <String>{for (final LuciTestResult r in results) r.resultId};
       expect(resultIds, hasLength(results.length));

       // The passing test ran from t=2ms to t=102ms => 0.1s.
       final LuciTestResult pass = results.firstWhere(
         (LuciTestResult r) => _caseName(r) == 'passing test',
       );
       expect(pass.duration, '0.100000s');
     });
   });

   group('ResultDbRecorder.fromEnvironment', () {
     test('returns null when resultdb is absent from LUCI_CONTEXT', () {
       final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
       addTearDown(() => tryToDelete(dir));
       final context = File('${dir.path}/luci_context.json')
         ..writeAsStringSync(json.encode(<String, Object?>{'luciexe': <String, Object?>{}}));
       expect(
         ResultDbRecorder.fromEnvironment(<String, String>{'LUCI_CONTEXT': context.path}),
         isNull,
       );
     });

     test('returns null (does not throw) when LUCI_CONTEXT is malformed JSON', () {
       final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
       addTearDown(() => tryToDelete(dir));
       final context = File('${dir.path}/luci_context.json')..writeAsStringSync('{not valid json');
       expect(
         ResultDbRecorder.fromEnvironment(<String, String>{'LUCI_CONTEXT': context.path}),
         isNull,
       );
     });

     test('parses hostname and current_invocation from LUCI_CONTEXT', () {
       final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
       addTearDown(() => tryToDelete(dir));
       final context = File('${dir.path}/luci_context.json')
         ..writeAsStringSync(
           json.encode(<String, Object?>{
             'resultdb': <String, Object?>{
               'hostname': 'results.api.luci.app',
               'current_invocation': <String, Object?>{
                 'name': 'invocations/build-123',
                 'update_token': 'tok',
               },
             },
           }),
         );
       final ResultDbRecorder? recorder = ResultDbRecorder.fromEnvironment(<String, String>{
         'LUCI_CONTEXT': context.path,
       });
       if (recorder case final rec?) {
         expect(
           (rec.host, rec.invocation, rec.updateToken),
           ('results.api.luci.app', 'invocations/build-123', 'tok'),
         );
         rec.close();
       } else {
         fail('Expected non-null recorder');
       }
     });
   });

   group('ResultDbRecorder.reportTestResults', () {
     test('serializes each result under requests[].testResult', () async {
       final HttpServer server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
       addTearDown(() => server.close(force: true));

       final bodies = <Map<String, Object?>>[];
       final tokens = <String>[];
       final paths = <String>[];
       server.listen((HttpRequest request) async {
         paths.add(request.uri.path);
         tokens.add(request.headers.value('update-token') ?? '');
         final String body = await utf8.decoder.bind(request).join();
         bodies.add(json.decode(body) as Map<String, Object?>);
         request.response.statusCode = HttpStatus.ok;
         request.response.write('{}');
         await request.response.close();
       });

       // Use a client whose https requests are redirected to our http server by
       // connecting directly; HttpClient does not allow that, so we instead
       // exercise the batching/serialization logic against the local server by
       // constructing the recorder with an http HttpClient is not needed: the
       // body format is what we assert here through the public API.
       final recorder = _HttpRecorder(
         host: '${server.address.host}:${server.port}',
         invocation: 'invocations/build-123',
         updateToken: 'my-token',
       );
       addTearDown(recorder.close);

       await recorder.reportTestResults(<LuciTestResult>[
         const LuciTestResult(
           testId: LuciStructuredTestId(moduleName: 'm', caseName: 'a'),
           resultId: '0',
           status: 'PASS',
           expected: true,
           duration: '0.000000s',
         ),
         const LuciTestResult(
           testId: LuciStructuredTestId(moduleName: 'm', caseName: 'b'),
           resultId: '1',
           status: 'FAIL',
           expected: false,
           duration: '0.000000s',
         ),
       ]);

       expect(bodies, hasLength(1));
       expect(paths.single, '/prpc/luci.resultdb.v1.Recorder/BatchCreateTestResults');
       expect(tokens.single, 'my-token');
       if (bodies.single case {
         'invocation': 'invocations/build-123',
         'requests': [{'testResult': {'testIdStructured': {'caseName': 'a'}}}, _],
       }) {
         // Matched expected structure.
       } else {
         fail('Unexpected body: ${bodies.single}');
       }
     });
   });
 }

 /// A [ResultDbRecorder] that talks plain HTTP, for testing against a local
 /// [HttpServer] (the production recorder always uses https).
 class _HttpRecorder extends ResultDbRecorder {
   _HttpRecorder({required super.host, required super.invocation, required super.updateToken});

   @override
   Future<void> reportTestResults(List<LuciTestResult> testResults) async {
     final client = HttpClient();
     try {
       final Uri url = Uri.parse(
         'http://$host/prpc/luci.resultdb.v1.Recorder/BatchCreateTestResults',
       );
       final HttpClientRequest request = await client.postUrl(url);
       request.headers.set(HttpHeaders.contentTypeHeader, 'application/json');
       request.headers.set('update-token', updateToken);
       request.add(
         utf8.encode(
           json.encode(<String, Object?>{
             'invocation': invocation,
             'requests': <Map<String, Object?>>[
               for (final LuciTestResult result in testResults)
                 <String, Object?>{'testResult': result.toJson()},
             ],
           }),
         ),
       );
       final HttpClientResponse response = await request.close();
       await response.drain<void>();
     } finally {
       client.close(force: true);
     }
   }
 }
	// Copyright 2014 The Flutter Authors. 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 'dart:io';

	import 'package:file/memory.dart';

	import '../luci_resultdb.dart';
	import '../tool_subsharding.dart';
	import 'common.dart';

	const String _kMetrics = '''
	{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}
	{"suite":{"id":0,"platform":"vm","path":"test/foo_test.dart"},"type":"suite","time":0}
	{"test":{"id":1,"name":"loading test/foo_test.dart","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":null,"column":null,"url":null},"type":"testStart","time":0}
	{"testID":1,"result":"success","skipped":false,"hidden":true,"type":"testDone","time":1}
	{"test":{"id":2,"name":"passing test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}
	{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}
	{"test":{"id":3,"name":"failing test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":20,"column":3,"url":"file:///foo"},"type":"testStart","time":102}
	{"testID":3,"result":"failure","skipped":false,"hidden":false,"type":"testDone","time":152}
	{"test":{"id":4,"name":"skipped test","suiteID":0,"groupIDs":[],"metadata":{"skip":true,"skipReason":null},"line":30,"column":3,"url":"file:///foo"},"type":"testStart","time":152}
	{"testID":4,"result":"success","skipped":true,"hidden":false,"type":"testDone","time":152}
	{"success":false,"type":"done","time":200}''';

	TestFileReporterResults _parse() {
	final fileSystem = MemoryFileSystem.test();
	final File file = fileSystem.file('metrics');
	file.writeAsStringSync(_kMetrics);
	return TestFileReporterResults.fromFile(file);
	}

	String _caseName(LuciTestResult result) => result.testId.caseName;

	void main() {
	group('convertToLuciTestResultsFormat', () {
	test('converts each non-hidden test into a structured ResultDB TestResult', () {
	final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());

	// The hidden "loading ..." bookkeeping test is excluded.
	expect(results, hasLength(3));

	final byCase = <String, LuciTestResult>{
	for (final LuciTestResult r in results) _caseName(r): r,
	};

	expect(byCase.keys, containsAll(<String>['passing test', 'failing test', 'skipped test']));
	// The module name is the test file, and the scheme is the level-free
	// 'flat' scheme, so file and test name are separate columns in the UI.
	for (final LuciTestResult(
	testId: LuciStructuredTestId(:moduleName, :moduleScheme, :moduleVariant),
	)
	in results) {
	expect(moduleName, 'test/foo_test.dart');
	expect(moduleScheme, 'flat');
	expect(moduleVariant, <String, String>{});
	}
	});

	test('strips rootDirectory prefix from absolute suite paths', () {
	const metrics =
	'{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
	'{"suite":{"id":0,"platform":"vm","path":"/b/s/w/ir/x/w/flutter/dev/foo/bar_test.dart"},"type":"suite","time":0}\n'
	'{"test":{"id":2,"name":"my test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
	'{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
	'{"success":true,"type":"done","time":200}';
	final fileSystem = MemoryFileSystem.test();
	final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
	final parsed = TestFileReporterResults.fromFile(file);

	final List<LuciTestResult> stripped = convertToLuciTestResultsFormat(
	parsed,
	rootDirectory: '/b/s/w/ir/x/w/flutter',
	);
	final [LuciTestResult(testId: LuciStructuredTestId(:moduleName, :caseName))] = stripped;
	expect(moduleName, 'dev/foo/bar_test.dart');
	expect(caseName, 'my test');

	// Without a rootDirectory, the absolute path is preserved.
	final [
	LuciTestResult(testId: LuciStructuredTestId(moduleName: String unstrippedModuleName)),
	] = convertToLuciTestResultsFormat(
	parsed,
	);
	expect(unstrippedModuleName, '/b/s/w/ir/x/w/flutter/dev/foo/bar_test.dart');
	});

	test('resolves relative suite paths against the working directory', () {
	const metrics =
	'{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
	'{"suite":{"id":0,"platform":"vm","path":"test/bar_test.dart"},"type":"suite","time":0}\n'
	'{"test":{"id":2,"name":"my test","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
	'{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
	'{"success":true,"type":"done","time":200}';
	final fileSystem = MemoryFileSystem.test();
	final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
	final parsed = TestFileReporterResults.fromFile(file);

	// A `packages/flutter` shard reports suite paths relative to its working
	// directory; resolving against it yields a repo-relative module name.
	final List<LuciTestResult> results = convertToLuciTestResultsFormat(
	parsed,
	workingDirectory: '/b/s/w/ir/x/w/flutter/packages/flutter',
	rootDirectory: '/b/s/w/ir/x/w/flutter',
	);
	final [LuciTestResult(testId: LuciStructuredTestId(:moduleName))] = results;
	expect(moduleName, 'packages/flutter/test/bar_test.dart');
	});

	test('escapes colons and backslashes in the case name', () {
	const metrics =
	'{"protocolVersion":"0.1.1","runnerVersion":"1.25.0","pid":1,"type":"start","time":0}\n'
	'{"suite":{"id":0,"platform":"vm","path":"test/foo_test.dart"},"type":"suite","time":0}\n'
	'{"test":{"id":2,"name":"Group: sub\\\\path does x","suiteID":0,"groupIDs":[],"metadata":{"skip":false,"skipReason":null},"line":10,"column":3,"url":"file:///foo"},"type":"testStart","time":2}\n'
	'{"testID":2,"result":"success","skipped":false,"hidden":false,"type":"testDone","time":102}\n'
	'{"success":true,"type":"done","time":200}';
	final fileSystem = MemoryFileSystem.test();
	final File file = fileSystem.file('metrics')..writeAsStringSync(metrics);
	final parsed = TestFileReporterResults.fromFile(file);

	final List<LuciTestResult> results = convertToLuciTestResultsFormat(parsed);
	// The raw test name is `Group: sub\path does x`; ':' becomes '\:' and the
	// backslash becomes '\\'.
	final [LuciTestResult(testId: LuciStructuredTestId(:caseName))] = results;
	expect(caseName, r'Group\: sub\\path does x');
	});

	test('maps status and expectedness correctly', () {
	final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());
	final byId = <String, LuciTestResult>{
	for (final LuciTestResult r in results) _caseName(r): r,
	};

	final LuciTestResult pass = byId['passing test']!;
	expect((pass.status, pass.expected), ('PASS', true));

	final LuciTestResult fail = byId['failing test']!;
	expect((fail.status, fail.expected), ('FAIL', false));

	final LuciTestResult skip = byId['skipped test']!;
	expect((skip.status, skip.expected), ('SKIP', true));
	});

	test('marks failing tests as expected when expectFailure is true', () {
	final List<LuciTestResult> results = convertToLuciTestResultsFormat(
	_parse(),
	expectFailure: true,
	);
	final byId = <String, LuciTestResult>{
	for (final LuciTestResult r in results) _caseName(r): r,
	};

	// The failing test keeps its FAIL status but is now an expected failure,
	// so ResultDB won't surface it as a red regression (e.g. the
	// test_smoke_test negative tests run with expectFailure: true).
	final LuciTestResult fail = byId['failing test']!;
	expect((fail.status, fail.expected), ('FAIL', true));

	// Passing and skipped tests remain expected as well.
	expect(byId['passing test']!.expected, true);
	expect(byId['skipped test']!.expected, true);
	});

	test('emits a proto Duration string and unique result ids', () {
	final List<LuciTestResult> results = convertToLuciTestResultsFormat(_parse());

	for (final r in results) {
	expect(r.duration, matches(r'^\d+\.\d+s$'));
	}
	final resultIds = <String>{for (final LuciTestResult r in results) r.resultId};
	expect(resultIds, hasLength(results.length));

	// The passing test ran from t=2ms to t=102ms => 0.1s.
	final LuciTestResult pass = results.firstWhere(
	(LuciTestResult r) => _caseName(r) == 'passing test',
	);
	expect(pass.duration, '0.100000s');
	});
	});

	group('ResultDbRecorder.fromEnvironment', () {
	test('returns null when resultdb is absent from LUCI_CONTEXT', () {
	final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
	addTearDown(() => tryToDelete(dir));
	final context = File('${dir.path}/luci_context.json')
	..writeAsStringSync(json.encode(<String, Object?>{'luciexe': <String, Object?>{}}));
	expect(
	ResultDbRecorder.fromEnvironment(<String, String>{'LUCI_CONTEXT': context.path}),
	isNull,
	);
	});

	test('returns null (does not throw) when LUCI_CONTEXT is malformed JSON', () {
	final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
	addTearDown(() => tryToDelete(dir));
	final context = File('${dir.path}/luci_context.json')..writeAsStringSync('{not valid json');
	expect(
	ResultDbRecorder.fromEnvironment(<String, String>{'LUCI_CONTEXT': context.path}),
	isNull,
	);
	});

	test('parses hostname and current_invocation from LUCI_CONTEXT', () {
	final Directory dir = Directory.systemTemp.createTempSync('luci_resultdb_test');
	addTearDown(() => tryToDelete(dir));
	final context = File('${dir.path}/luci_context.json')
	..writeAsStringSync(
	json.encode(<String, Object?>{
	'resultdb': <String, Object?>{
	'hostname': 'results.api.luci.app',
	'current_invocation': <String, Object?>{
	'name': 'invocations/build-123',
	'update_token': 'tok',
	},
	},
	}),
	);
	final ResultDbRecorder? recorder = ResultDbRecorder.fromEnvironment(<String, String>{
	'LUCI_CONTEXT': context.path,
	});
	if (recorder case final rec?) {
	expect(
	(rec.host, rec.invocation, rec.updateToken),
	('results.api.luci.app', 'invocations/build-123', 'tok'),
	);
	rec.close();
	} else {
	fail('Expected non-null recorder');
	}
	});
	});

	group('ResultDbRecorder.reportTestResults', () {
	test('serializes each result under requests[].testResult', () async {
	final HttpServer server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
	addTearDown(() => server.close(force: true));

	final bodies = <Map<String, Object?>>[];
	final tokens = <String>[];
	final paths = <String>[];
	server.listen((HttpRequest request) async {
	paths.add(request.uri.path);
	tokens.add(request.headers.value('update-token') ?? '');
	final String body = await utf8.decoder.bind(request).join();
	bodies.add(json.decode(body) as Map<String, Object?>);
	request.response.statusCode = HttpStatus.ok;
	request.response.write('{}');
	await request.response.close();
	});

	// Use a client whose https requests are redirected to our http server by
	// connecting directly; HttpClient does not allow that, so we instead
	// exercise the batching/serialization logic against the local server by
	// constructing the recorder with an http HttpClient is not needed: the
	// body format is what we assert here through the public API.
	final recorder = _HttpRecorder(
	host: '${server.address.host}:${server.port}',
	invocation: 'invocations/build-123',
	updateToken: 'my-token',
	);
	addTearDown(recorder.close);

	await recorder.reportTestResults(<LuciTestResult>[
	const LuciTestResult(
	testId: LuciStructuredTestId(moduleName: 'm', caseName: 'a'),
	resultId: '0',
	status: 'PASS',
	expected: true,
	duration: '0.000000s',
	),
	const LuciTestResult(
	testId: LuciStructuredTestId(moduleName: 'm', caseName: 'b'),
	resultId: '1',
	status: 'FAIL',
	expected: false,
	duration: '0.000000s',
	),
	]);

	expect(bodies, hasLength(1));
	expect(paths.single, '/prpc/luci.resultdb.v1.Recorder/BatchCreateTestResults');
	expect(tokens.single, 'my-token');
	if (bodies.single case {
	'invocation': 'invocations/build-123',
	'requests': [{'testResult': {'testIdStructured': {'caseName': 'a'}}}, _],
	}) {
	// Matched expected structure.
	} else {
	fail('Unexpected body: ${bodies.single}');
	}
	});
	});
	}

	/// A [ResultDbRecorder] that talks plain HTTP, for testing against a local
	/// [HttpServer] (the production recorder always uses https).
	class _HttpRecorder extends ResultDbRecorder {
	_HttpRecorder({required super.host, required super.invocation, required super.updateToken});

	@override
	Future<void> reportTestResults(List<LuciTestResult> testResults) async {
	final client = HttpClient();
	try {
	final Uri url = Uri.parse(
	'http://$host/prpc/luci.resultdb.v1.Recorder/BatchCreateTestResults',
	);
	final HttpClientRequest request = await client.postUrl(url);
	request.headers.set(HttpHeaders.contentTypeHeader, 'application/json');
	request.headers.set('update-token', updateToken);
	request.add(
	utf8.encode(
	json.encode(<String, Object?>{
	'invocation': invocation,
	'requests': <Map<String, Object?>>[
	for (final LuciTestResult result in testResults)
	<String, Object?>{'testResult': result.toJson()},
	],
	}),
	),
	);
	final HttpClientResponse response = await request.close();
	await response.drain<void>();
	} finally {
	client.close(force: true);
	}
	}
	}