mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
b2d90eb6d3
This works around https://g-issues.skia.org/issues/40044713 using exponential backoff. This is completely untested because I have no idea how to test it. Also I only changed one of the code paths here. I figure if we get success here then we can start propagating the change to other places in this file that generate errors, maybe factoring out the retry and error reporting logic so it's not duplicated multiple times.
607 lines
22 KiB
Dart
607 lines
22 KiB
Dart
// 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' as io;
|
|
|
|
import 'package:crypto/crypto.dart';
|
|
import 'package:file/file.dart';
|
|
import 'package:file/local.dart';
|
|
import 'package:path/path.dart' as path;
|
|
import 'package:platform/platform.dart';
|
|
import 'package:process/process.dart';
|
|
|
|
// If you are here trying to figure out how to use golden files in the Flutter
|
|
// repo itself, consider reading this wiki page:
|
|
// https://github.com/flutter/flutter/wiki/Writing-a-golden-file-test-for-package%3Aflutter
|
|
|
|
const String _kFlutterRootKey = 'FLUTTER_ROOT';
|
|
const String _kGoldctlKey = 'GOLDCTL';
|
|
const String _kTestBrowserKey = 'FLUTTER_TEST_BROWSER';
|
|
const String _kWebRendererKey = 'FLUTTER_WEB_RENDERER';
|
|
|
|
/// Exception thrown when an error is returned from the [SkiaClient].
|
|
class SkiaException implements Exception {
|
|
/// Creates a new `SkiaException` with a required error [message].
|
|
const SkiaException(this.message);
|
|
|
|
/// A message describing the error.
|
|
final String message;
|
|
|
|
/// Returns a description of the Skia exception.
|
|
///
|
|
/// The description always contains the [message].
|
|
@override
|
|
String toString() => 'SkiaException: $message';
|
|
}
|
|
|
|
/// A client for uploading image tests and making baseline requests to the
|
|
/// Flutter Gold Dashboard.
|
|
class SkiaGoldClient {
|
|
/// Creates a [SkiaGoldClient] with the given [workDirectory].
|
|
///
|
|
/// All other parameters are optional. They may be provided in tests to
|
|
/// override the defaults for [fs], [process], [platform], and [httpClient].
|
|
SkiaGoldClient(
|
|
this.workDirectory, {
|
|
this.fs = const LocalFileSystem(),
|
|
this.process = const LocalProcessManager(),
|
|
this.platform = const LocalPlatform(),
|
|
io.HttpClient? httpClient,
|
|
}) : httpClient = httpClient ?? io.HttpClient();
|
|
|
|
/// The file system to use for storing the local clone of the repository.
|
|
///
|
|
/// This is useful in tests, where a local file system (the default) can be
|
|
/// replaced by a memory file system.
|
|
final FileSystem fs;
|
|
|
|
/// A wrapper for the [dart:io.Platform] API.
|
|
///
|
|
/// This is useful in tests, where the system platform (the default) can be
|
|
/// replaced by a mock platform instance.
|
|
final Platform platform;
|
|
|
|
/// A controller for launching sub-processes.
|
|
///
|
|
/// This is useful in tests, where the real process manager (the default) can
|
|
/// be replaced by a mock process manager that doesn't really create
|
|
/// sub-processes.
|
|
final ProcessManager process;
|
|
|
|
/// A client for making Http requests to the Flutter Gold dashboard.
|
|
final io.HttpClient httpClient;
|
|
|
|
/// The local [Directory] within the [comparisonRoot] for the current test
|
|
/// context. In this directory, the client will create image and JSON files
|
|
/// for the goldctl tool to use.
|
|
///
|
|
/// This is informed by the [FlutterGoldenFileComparator] [basedir]. It cannot
|
|
/// be null.
|
|
final Directory workDirectory;
|
|
|
|
/// The local [Directory] where the Flutter repository is hosted.
|
|
///
|
|
/// Uses the [fs] file system.
|
|
Directory get _flutterRoot => fs.directory(platform.environment[_kFlutterRootKey]);
|
|
|
|
/// The path to the local [Directory] where the goldctl tool is hosted.
|
|
///
|
|
/// Uses the [platform] environment in this implementation.
|
|
String get _goldctl => platform.environment[_kGoldctlKey]!;
|
|
|
|
/// Prepares the local work space for golden file testing and calls the
|
|
/// goldctl `auth` command.
|
|
///
|
|
/// This ensures that the goldctl tool is authorized and ready for testing.
|
|
/// Used by the [FlutterPostSubmitFileComparator] and the
|
|
/// [FlutterPreSubmitFileComparator].
|
|
Future<void> auth() async {
|
|
if (await clientIsAuthorized()) {
|
|
return;
|
|
}
|
|
final List<String> authCommand = <String>[
|
|
_goldctl,
|
|
'auth',
|
|
'--work-dir', workDirectory
|
|
.childDirectory('temp')
|
|
.path,
|
|
'--luci',
|
|
];
|
|
|
|
final io.ProcessResult result = await process.run(authCommand);
|
|
|
|
if (result.exitCode != 0) {
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('Skia Gold authorization failed.')
|
|
..writeln('Luci environments authenticate using the file provided '
|
|
'by LUCI_CONTEXT. There may be an error with this file or Gold '
|
|
'authentication.')
|
|
..writeln('Debug information for Gold --------------------------------')
|
|
..writeln('stdout: ${result.stdout}')
|
|
..writeln('stderr: ${result.stderr}');
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
}
|
|
|
|
/// Signals if this client is initialized for uploading images to the Gold
|
|
/// service.
|
|
///
|
|
/// Since Flutter framework tests are executed in parallel, and in random
|
|
/// order, this will signal is this instance of the Gold client has been
|
|
/// initialized.
|
|
bool _initialized = false;
|
|
|
|
/// Executes the `imgtest init` command in the goldctl tool.
|
|
///
|
|
/// The `imgtest` command collects and uploads test results to the Skia Gold
|
|
/// backend, the `init` argument initializes the current test. Used by the
|
|
/// [FlutterPostSubmitFileComparator].
|
|
Future<void> imgtestInit() async {
|
|
// This client has already been initialized
|
|
if (_initialized) {
|
|
return;
|
|
}
|
|
|
|
final File keys = workDirectory.childFile('keys.json');
|
|
final File failures = workDirectory.childFile('failures.json');
|
|
|
|
await keys.writeAsString(_getKeysJSON());
|
|
await failures.create();
|
|
final String commitHash = await _getCurrentCommit();
|
|
|
|
final List<String> imgtestInitCommand = <String>[
|
|
_goldctl,
|
|
'imgtest', 'init',
|
|
'--instance', 'flutter',
|
|
'--work-dir', workDirectory
|
|
.childDirectory('temp')
|
|
.path,
|
|
'--commit', commitHash,
|
|
'--keys-file', keys.path,
|
|
'--failure-file', failures.path,
|
|
'--passfail',
|
|
];
|
|
|
|
if (imgtestInitCommand.contains(null)) {
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('A null argument was provided for Skia Gold imgtest init.')
|
|
..writeln('Please confirm the settings of your golden file test.')
|
|
..writeln('Arguments provided:');
|
|
imgtestInitCommand.forEach(buf.writeln);
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
|
|
final io.ProcessResult result = await process.run(imgtestInitCommand);
|
|
|
|
if (result.exitCode != 0) {
|
|
_initialized = false;
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('Skia Gold imgtest init failed.')
|
|
..writeln('An error occurred when initializing golden file test with ')
|
|
..writeln('goldctl.')
|
|
..writeln()
|
|
..writeln('Debug information for Gold --------------------------------')
|
|
..writeln('stdout: ${result.stdout}')
|
|
..writeln('stderr: ${result.stderr}');
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
_initialized = true;
|
|
}
|
|
|
|
/// Executes the `imgtest add` command in the goldctl tool.
|
|
///
|
|
/// The `imgtest` command collects and uploads test results to the Skia Gold
|
|
/// backend, the `add` argument uploads the current image test. A response is
|
|
/// returned from the invocation of this command that indicates a pass or fail
|
|
/// result.
|
|
///
|
|
/// The [testName] and [goldenFile] parameters reference the current
|
|
/// comparison being evaluated by the [FlutterPostSubmitFileComparator].
|
|
Future<bool> imgtestAdd(String testName, File goldenFile) async {
|
|
final List<String> imgtestCommand = <String>[
|
|
_goldctl,
|
|
'imgtest', 'add',
|
|
'--work-dir', workDirectory
|
|
.childDirectory('temp')
|
|
.path,
|
|
'--test-name', cleanTestName(testName),
|
|
'--png-file', goldenFile.path,
|
|
'--passfail',
|
|
..._getPixelMatchingArguments(),
|
|
];
|
|
|
|
final io.ProcessResult result = await process.run(imgtestCommand);
|
|
|
|
if (result.exitCode != 0) {
|
|
// If an unapproved image has made it to post-submit, throw to close the
|
|
// tree.
|
|
String? resultContents;
|
|
final File resultFile = workDirectory.childFile(fs.path.join(
|
|
'result-state.json',
|
|
));
|
|
if (await resultFile.exists()) {
|
|
resultContents = await resultFile.readAsString();
|
|
}
|
|
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('Skia Gold received an unapproved image in post-submit ')
|
|
..writeln('testing. Golden file images in flutter/flutter are triaged ')
|
|
..writeln('in pre-submit during code review for the given PR.')
|
|
..writeln()
|
|
..writeln('Visit https://flutter-gold.skia.org/ to view and approve ')
|
|
..writeln('the image(s), or revert the associated change. For more ')
|
|
..writeln('information, visit the wiki: ')
|
|
..writeln('https://github.com/flutter/flutter/wiki/Writing-a-golden-file-test-for-package:flutter')
|
|
..writeln()
|
|
..writeln('Debug information for Gold --------------------------------')
|
|
..writeln('stdout: ${result.stdout}')
|
|
..writeln('stderr: ${result.stderr}')
|
|
..writeln()
|
|
..writeln('result-state.json: ${resultContents ?? 'No result file found.'}');
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Signals if this client is initialized for uploading tryjobs to the Gold
|
|
/// service.
|
|
///
|
|
/// Since Flutter framework tests are executed in parallel, and in random
|
|
/// order, this will signal is this instance of the Gold client has been
|
|
/// initialized for tryjobs.
|
|
bool _tryjobInitialized = false;
|
|
|
|
/// Executes the `imgtest init` command in the goldctl tool for tryjobs.
|
|
///
|
|
/// The `imgtest` command collects and uploads test results to the Skia Gold
|
|
/// backend, the `init` argument initializes the current tryjob. Used by the
|
|
/// [FlutterPreSubmitFileComparator].
|
|
Future<void> tryjobInit() async {
|
|
// This client has already been initialized
|
|
if (_tryjobInitialized) {
|
|
return;
|
|
}
|
|
|
|
final File keys = workDirectory.childFile('keys.json');
|
|
final File failures = workDirectory.childFile('failures.json');
|
|
|
|
await keys.writeAsString(_getKeysJSON());
|
|
await failures.create();
|
|
final String commitHash = await _getCurrentCommit();
|
|
|
|
final List<String> imgtestInitCommand = <String>[
|
|
_goldctl,
|
|
'imgtest', 'init',
|
|
'--instance', 'flutter',
|
|
'--work-dir', workDirectory
|
|
.childDirectory('temp')
|
|
.path,
|
|
'--commit', commitHash,
|
|
'--keys-file', keys.path,
|
|
'--failure-file', failures.path,
|
|
'--passfail',
|
|
'--crs', 'github',
|
|
'--patchset_id', commitHash,
|
|
...getCIArguments(),
|
|
];
|
|
|
|
if (imgtestInitCommand.contains(null)) {
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('A null argument was provided for Skia Gold tryjob init.')
|
|
..writeln('Please confirm the settings of your golden file test.')
|
|
..writeln('Arguments provided:');
|
|
imgtestInitCommand.forEach(buf.writeln);
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
|
|
final io.ProcessResult result = await process.run(imgtestInitCommand);
|
|
|
|
if (result.exitCode != 0) {
|
|
_tryjobInitialized = false;
|
|
final StringBuffer buf = StringBuffer()
|
|
..writeln('Skia Gold tryjobInit failure.')
|
|
..writeln('An error occurred when initializing golden file tryjob with ')
|
|
..writeln('goldctl.')
|
|
..writeln()
|
|
..writeln('Debug information for Gold --------------------------------')
|
|
..writeln('stdout: ${result.stdout}')
|
|
..writeln('stderr: ${result.stderr}');
|
|
throw SkiaException(buf.toString());
|
|
}
|
|
_tryjobInitialized = true;
|
|
}
|
|
|
|
static void _addIndented(StringBuffer buffer, String text) {
|
|
if (text.isEmpty) {
|
|
buffer.writeln(' <empty>');
|
|
} else {
|
|
for (final String line in text.split('\n')) {
|
|
buffer.writeln(' $line');
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Executes the `imgtest add` command in the goldctl tool for tryjobs.
|
|
///
|
|
/// The `imgtest` command collects and uploads test results to the Skia Gold
|
|
/// backend, the `add` argument uploads the current image test. A response is
|
|
/// returned from the invocation of this command that indicates a pass or fail
|
|
/// result for the tryjob.
|
|
///
|
|
/// The [testName] and [goldenFile] parameters reference the current
|
|
/// comparison being evaluated by the [FlutterPreSubmitFileComparator].
|
|
Future<void> tryjobAdd(String testName, File goldenFile) async {
|
|
Duration delay = const Duration(seconds: 5);
|
|
while (true) {
|
|
final io.ProcessResult result = await process.run(<String>[
|
|
_goldctl,
|
|
'imgtest', 'add',
|
|
'--work-dir', workDirectory.childDirectory('temp').path,
|
|
'--test-name', cleanTestName(testName),
|
|
'--png-file', goldenFile.path,
|
|
..._getPixelMatchingArguments(),
|
|
]);
|
|
|
|
final String resultStdout = result.stdout as String;
|
|
final String resultStderr = result.stderr as String;
|
|
if (result.exitCode == 0 ||
|
|
resultStdout.contains('Untriaged') ||
|
|
resultStdout.contains('negative image')) {
|
|
return; // success
|
|
}
|
|
|
|
if (resultStdout.contains('502')) {
|
|
// probably a transient error, try again
|
|
// Ideally we'd use something like package:test's printOnError, but best reliability
|
|
// in getting logs on CI for now we're just using print.
|
|
// See also: https://github.com/flutter/flutter/issues/91285
|
|
print('Transient failure from Skia Gold, retrying in ${delay.inSeconds} seconds.'); // ignore: avoid_print
|
|
print(''); // ignore: avoid_print
|
|
print('stdout from gold:'); // ignore: avoid_print
|
|
final StringBuffer buffer = StringBuffer();
|
|
_addIndented(buffer, resultStdout);
|
|
print(buffer); // ignore: avoid_print
|
|
await Future<void>.delayed(delay);
|
|
delay *= 2;
|
|
continue; // retry
|
|
}
|
|
|
|
final StringBuffer buffer = StringBuffer()
|
|
..write('Golden test for "$testName" failed with exit code ${result.exitCode} ')
|
|
..writeln('for a reason unrelated to pixel comparison.');
|
|
if (resultStdout.isNotEmpty) {
|
|
buffer
|
|
..writeln()
|
|
..writeln('stdout from gold:');
|
|
_addIndented(buffer, resultStdout);
|
|
}
|
|
if (resultStderr.isNotEmpty) {
|
|
buffer
|
|
..writeln()
|
|
..writeln('stderr from gold:');
|
|
_addIndented(buffer, resultStderr);
|
|
}
|
|
final File resultFile = workDirectory.childFile('result-state.json');
|
|
if (await resultFile.exists()) {
|
|
buffer
|
|
..writeln()
|
|
..writeln('result-state.json contents:');
|
|
_addIndented(buffer, resultFile.readAsStringSync());
|
|
}
|
|
throw SkiaException(buffer.toString()); // failure
|
|
}
|
|
}
|
|
|
|
// Constructs arguments for `goldctl` for controlling how pixels are compared.
|
|
//
|
|
// For AOT and CanvasKit exact pixel matching is used. For the HTML renderer
|
|
// on the web a fuzzy matching algorithm is used that allows very small deltas
|
|
// because Chromium cannot exactly reproduce the same golden on all computers.
|
|
// It seems to depend on the hardware/OS/driver combination. However, those
|
|
// differences are very small (typically not noticeable to human eye).
|
|
List<String> _getPixelMatchingArguments() {
|
|
// Only use fuzzy pixel matching in the HTML renderer.
|
|
if (!_isBrowserTest || _isBrowserCanvasKitTest) {
|
|
return const <String>[];
|
|
}
|
|
|
|
// The algorithm to be used when matching images. The available options are:
|
|
// - "fuzzy": Allows for customizing the thresholds of pixel differences.
|
|
// - "sobel": Same as "fuzzy" but performs edge detection before performing
|
|
// a fuzzy match.
|
|
const String algorithm = 'fuzzy';
|
|
|
|
// The number of pixels in this image that are allowed to differ from the
|
|
// baseline.
|
|
//
|
|
// The chosen number - 20 - is arbitrary. Even for a small golden file, say
|
|
// 50 x 50, it would be less than 1% of the total number of pixels. This
|
|
// number should not grow too much. If it's growing, it is probably due to a
|
|
// larger issue that needs to be addressed at the infra level.
|
|
const int maxDifferentPixels = 20;
|
|
|
|
// The maximum acceptable difference per pixel.
|
|
//
|
|
// Uses the Manhattan distance using the RGBA color components as
|
|
// coordinates. The chosen number - 4 - is arbitrary. It's small enough to
|
|
// both not be noticeable and not trigger test flakes due to sub-pixel
|
|
// golden deltas. This number should not grow too much. If it's growing, it
|
|
// is probably due to a larger issue that needs to be addressed at the infra
|
|
// level.
|
|
const int pixelDeltaThreshold = 4;
|
|
|
|
return <String>[
|
|
'--add-test-optional-key', 'image_matching_algorithm:$algorithm',
|
|
'--add-test-optional-key', 'fuzzy_max_different_pixels:$maxDifferentPixels',
|
|
'--add-test-optional-key', 'fuzzy_pixel_delta_threshold:$pixelDeltaThreshold',
|
|
];
|
|
}
|
|
|
|
/// Returns the latest positive digest for the given test known to Flutter
|
|
/// Gold at head.
|
|
Future<String?> getExpectationForTest(String testName) async {
|
|
late String? expectation;
|
|
final String traceID = getTraceID(testName);
|
|
await io.HttpOverrides.runWithHttpOverrides<Future<void>>(() async {
|
|
final Uri requestForExpectations = Uri.parse(
|
|
'https://flutter-gold.skia.org/json/v2/latestpositivedigest/$traceID'
|
|
);
|
|
late String rawResponse;
|
|
try {
|
|
final io.HttpClientRequest request = await httpClient.getUrl(requestForExpectations);
|
|
final io.HttpClientResponse response = await request.close();
|
|
rawResponse = await utf8.decodeStream(response);
|
|
final dynamic jsonResponse = json.decode(rawResponse);
|
|
if (jsonResponse is! Map<String, dynamic>) {
|
|
throw const FormatException('Skia gold expectations do not match expected format.');
|
|
}
|
|
expectation = jsonResponse['digest'] as String?;
|
|
} on FormatException catch (error) {
|
|
// Ideally we'd use something like package:test's printOnError, but best reliability
|
|
// in getting logs on CI for now we're just using print.
|
|
// See also: https://github.com/flutter/flutter/issues/91285
|
|
print( // ignore: avoid_print
|
|
'Formatting error detected requesting expectations from Flutter Gold.\n'
|
|
'error: $error\n'
|
|
'url: $requestForExpectations\n'
|
|
'response: $rawResponse'
|
|
);
|
|
rethrow;
|
|
}
|
|
},
|
|
SkiaGoldHttpOverrides(),
|
|
);
|
|
return expectation;
|
|
}
|
|
|
|
/// Returns a list of bytes representing the golden image retrieved from the
|
|
/// Flutter Gold dashboard.
|
|
///
|
|
/// The provided image hash represents an expectation from Flutter Gold.
|
|
Future<List<int>>getImageBytes(String imageHash) async {
|
|
final List<int> imageBytes = <int>[];
|
|
await io.HttpOverrides.runWithHttpOverrides<Future<void>>(() async {
|
|
final Uri requestForImage = Uri.parse(
|
|
'https://flutter-gold.skia.org/img/images/$imageHash.png',
|
|
);
|
|
final io.HttpClientRequest request = await httpClient.getUrl(requestForImage);
|
|
final io.HttpClientResponse response = await request.close();
|
|
await response.forEach((List<int> bytes) => imageBytes.addAll(bytes));
|
|
},
|
|
SkiaGoldHttpOverrides(),
|
|
);
|
|
return imageBytes;
|
|
}
|
|
|
|
/// Returns the current commit hash of the Flutter repository.
|
|
Future<String> _getCurrentCommit() async {
|
|
if (!_flutterRoot.existsSync()) {
|
|
throw SkiaException('Flutter root could not be found: $_flutterRoot\n');
|
|
} else {
|
|
final io.ProcessResult revParse = await process.run(
|
|
<String>['git', 'rev-parse', 'HEAD'],
|
|
workingDirectory: _flutterRoot.path,
|
|
);
|
|
if (revParse.exitCode != 0) {
|
|
throw const SkiaException('Current commit of Flutter can not be found.');
|
|
}
|
|
return (revParse.stdout as String/*!*/).trim();
|
|
}
|
|
}
|
|
|
|
/// Returns a JSON String with keys value pairs used to uniquely identify the
|
|
/// configuration that generated the given golden file.
|
|
///
|
|
/// Currently, the only key value pairs being tracked is the platform the
|
|
/// image was rendered on, and for web tests, the browser the image was
|
|
/// rendered on.
|
|
String _getKeysJSON() {
|
|
final Map<String, dynamic> keys = <String, dynamic>{
|
|
'Platform' : platform.operatingSystem,
|
|
'CI' : 'luci',
|
|
};
|
|
if (_isBrowserTest) {
|
|
keys['Browser'] = _browserKey;
|
|
keys['Platform'] = '${keys['Platform']}-browser';
|
|
if (_isBrowserCanvasKitTest) {
|
|
keys['WebRenderer'] = 'canvaskit';
|
|
}
|
|
}
|
|
return json.encode(keys);
|
|
}
|
|
|
|
/// Removes the file extension from the [fileName] to represent the test name
|
|
/// properly.
|
|
String cleanTestName(String fileName) {
|
|
return fileName.split(path.extension(fileName))[0];
|
|
}
|
|
|
|
/// Returns a boolean value to prevent the client from re-authorizing itself
|
|
/// for multiple tests.
|
|
Future<bool> clientIsAuthorized() async {
|
|
final File authFile = workDirectory.childFile(fs.path.join(
|
|
'temp',
|
|
'auth_opt.json',
|
|
))/*!*/;
|
|
|
|
if (await authFile.exists()) {
|
|
final String contents = await authFile.readAsString();
|
|
final Map<String, dynamic> decoded = json.decode(contents) as Map<String, dynamic>;
|
|
return !(decoded['GSUtil'] as bool/*!*/);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Returns a list of arguments for initializing a tryjob based on the testing
|
|
/// environment.
|
|
List<String> getCIArguments() {
|
|
final String jobId = platform.environment['LOGDOG_STREAM_PREFIX']!.split('/').last;
|
|
final List<String> refs = platform.environment['GOLD_TRYJOB']!.split('/');
|
|
final String pullRequest = refs[refs.length - 2];
|
|
|
|
return <String>[
|
|
'--changelist', pullRequest,
|
|
'--cis', 'buildbucket',
|
|
'--jobid', jobId,
|
|
];
|
|
}
|
|
|
|
bool get _isBrowserTest {
|
|
return platform.environment[_kTestBrowserKey] != null;
|
|
}
|
|
|
|
bool get _isBrowserCanvasKitTest {
|
|
return _isBrowserTest && platform.environment[_kWebRendererKey] == 'canvaskit';
|
|
}
|
|
|
|
String get _browserKey {
|
|
assert(_isBrowserTest);
|
|
return platform.environment[_kTestBrowserKey]!;
|
|
}
|
|
|
|
/// Returns a trace id based on the current testing environment to lookup
|
|
/// the latest positive digest on Flutter Gold with a hex-encoded md5 hash of
|
|
/// the image keys.
|
|
String getTraceID(String testName) {
|
|
final Map<String, dynamic> keys = <String, dynamic>{
|
|
if (_isBrowserTest)
|
|
'Browser' : _browserKey,
|
|
if (_isBrowserCanvasKitTest)
|
|
'WebRenderer' : 'canvaskit',
|
|
'CI' : 'luci',
|
|
'Platform' : platform.operatingSystem,
|
|
'name' : testName,
|
|
'source_type' : 'flutter',
|
|
};
|
|
final String jsonTrace = json.encode(keys);
|
|
final String md5Sum = md5.convert(utf8.encode(jsonTrace)).toString();
|
|
return md5Sum;
|
|
}
|
|
}
|
|
|
|
/// Used to make HttpRequests during testing.
|
|
class SkiaGoldHttpOverrides extends io.HttpOverrides { }
|