flutter_goldens.dart 20 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5 6 7
import 'dart:async' show FutureOr;
import 'dart:io' as io show OSError, SocketException;
import 'dart:typed_data' show Uint8List;
8 9 10

import 'package:file/file.dart';
import 'package:file/local.dart';
11
import 'package:flutter/foundation.dart';
12
import 'package:flutter_goldens_client/skia_client.dart';
13
import 'package:flutter_test/flutter_test.dart';
14
import 'package:platform/platform.dart';
15

16
export 'package:flutter_goldens_client/skia_client.dart';
17

18 19 20 21 22 23
// 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';

24 25
/// Main method that can be used in a `flutter_test_config.dart` file to set
/// [goldenFileComparator] to an instance of [FlutterGoldenFileComparator] that
26 27
/// works for the current test. _Which_ FlutterGoldenFileComparator is
/// instantiated is based on the current testing environment.
28
Future<void> testExecutable(FutureOr<void> Function() testMain) async {
29
  const Platform platform = LocalPlatform();
30 31
  if (FlutterPostSubmitFileComparator.isAvailableForEnvironment(platform)) {
    goldenFileComparator = await FlutterPostSubmitFileComparator.fromDefaultComparator(platform);
32 33
  } else if (FlutterPreSubmitFileComparator.isAvailableForEnvironment(platform)) {
    goldenFileComparator = await FlutterPreSubmitFileComparator.fromDefaultComparator(platform);
34 35
  } else if (FlutterSkippingFileComparator.isAvailableForEnvironment(platform)) {
    goldenFileComparator = FlutterSkippingFileComparator.fromDefaultComparator(
36
      'Golden file testing is not executed on Cirrus, or LUCI environments outside of flutter/flutter.'
37
    );
38 39
  } else {
    goldenFileComparator = await FlutterLocalFileComparator.fromDefaultComparator(platform);
40
  }
41

42 43 44
  await testMain();
}

45 46
/// Abstract base class golden file comparator specific to the `flutter/flutter`
/// repository.
47 48 49 50 51
///
/// Golden file testing for the `flutter/flutter` repository is handled by three
/// different [FlutterGoldenFileComparator]s, depending on the current testing
/// environment.
///
52
///   * The [FlutterPostSubmitFileComparator] is utilized during post-submit
53 54 55 56 57 58 59
///     testing, after a pull request has landed on the master branch. This
///     comparator uses the [SkiaGoldClient] and the `goldctl` tool to upload
///     tests to the [Flutter Gold dashboard](https://flutter-gold.skia.org).
///     Flutter Gold manages the master golden files for the `flutter/flutter`
///     repository.
///
///   * The [FlutterPreSubmitFileComparator] is utilized in pre-submit testing,
60
///     before a pull request lands on the master branch. This
61 62 63
///     comparator uses the [SkiaGoldClient] to execute tryjobs, allowing
///     contributors to view and check in visual differences before landing the
///     change.
64
///
65
///   * The [FlutterLocalFileComparator] is used for local development testing.
66 67
///     This comparator will use the [SkiaGoldClient] to request baseline images
///     from [Flutter Gold](https://flutter-gold.skia.org) and manually compare
68
///     pixels. If a difference is detected, this comparator will
69 70 71
///     generate failure output illustrating the found difference. If a baseline
///     is not found for a given test image, it will consider it a new test and
///     output the new image for verification.
72 73
///
///  The [FlutterSkippingFileComparator] is utilized to skip tests outside
74 75 76 77
///  of the appropriate environments described above. Currently, some Luci
///  environments do not execute golden file testing, and as such do not require
///  a comparator. This comparator is also used when an internet connection is
///  unavailable.
78
abstract class FlutterGoldenFileComparator extends GoldenFileComparator {
79
  /// Creates a [FlutterGoldenFileComparator] that will resolve golden file
80 81 82 83 84
  /// URIs relative to the specified [basedir], and retrieve golden baselines
  /// using the [skiaClient]. The [basedir] is used for writing and accessing
  /// information and files for interacting with the [skiaClient]. When testing
  /// locally, the [basedir] will also contain any diffs from failed tests, or
  /// goldens generated from newly introduced tests.
85
  ///
86 87
  /// The [fs] and [platform] parameters are useful in tests, where the default
  /// file system and platform can be replaced by mock instances.
88 89
  @visibleForTesting
  FlutterGoldenFileComparator(
90 91
    this.basedir,
    this.skiaClient, {
92
    this.fs = const LocalFileSystem(),
93
    this.platform = const LocalPlatform(),
94
  });
95

96
  /// The directory to which golden file URIs will be resolved in [compare] and
97
  /// [update], cannot be null.
98
  final Uri basedir;
99

100 101 102 103
  /// A client for uploading image tests and making baseline requests to the
  /// Flutter Gold Dashboard, cannot be null.
  final SkiaGoldClient skiaClient;

104 105
  /// The file system used to perform file access.
  @visibleForTesting
106 107
  final FileSystem fs;

108 109 110 111 112 113 114 115 116 117 118
  /// A wrapper for the [dart:io.Platform] API.
  @visibleForTesting
  final Platform platform;

  @override
  Future<void> update(Uri golden, Uint8List imageBytes) async {
    final File goldenFile = getGoldenFile(golden);
    await goldenFile.parent.create(recursive: true);
    await goldenFile.writeAsBytes(imageBytes, flush: true);
  }

119
  @override
120
  Uri getTestUri(Uri key, int? version) => key;
121

122
  /// Calculate the appropriate basedir for the current test context.
123 124
  ///
  /// The optional [suffix] argument is used by the
125
  /// [FlutterPostSubmitFileComparator] and the [FlutterPreSubmitFileComparator].
126 127
  /// These [FlutterGoldenFileComparators] randomize their base directories to
  /// maintain thread safety while using the `goldctl` tool.
128 129
  @protected
  @visibleForTesting
130 131 132
  static Directory getBaseDirectory(
    LocalFileComparator defaultComparator,
    Platform platform, {
133
    String? suffix,
134
  }) {
135 136
    const FileSystem fs = LocalFileSystem();
    final Directory flutterRoot = fs.directory(platform.environment[_kFlutterRootKey]);
137 138
    Directory comparisonRoot;

139 140
    if (suffix != null) {
      comparisonRoot = fs.systemTempDirectory.createTempSync(suffix);
141 142 143 144 145 146 147 148 149 150 151
    } else {
      comparisonRoot = flutterRoot.childDirectory(
        fs.path.join(
          'bin',
          'cache',
          'pkg',
          'skia_goldens',
        )
      );
    }

152
    final Directory testDirectory = fs.directory(defaultComparator.basedir);
153 154 155 156 157
    final String testDirectoryRelativePath = fs.path.relative(
      testDirectory.path,
      from: flutterRoot.path,
    );
    return comparisonRoot.childDirectory(testDirectoryRelativePath);
158 159 160 161 162 163 164 165
  }

  /// Returns the golden [File] identified by the given [Uri].
  @protected
  File getGoldenFile(Uri uri) {
    final File goldenFile = fs.directory(basedir).childFile(fs.file(uri).path);
    return goldenFile;
  }
166

167
  /// Prepends the golden URL with the library name that encloses the current
168 169 170
  /// test.
  Uri _addPrefix(Uri golden) {
    final String prefix = basedir.pathSegments[basedir.pathSegments.length - 2];
171
    return Uri.parse('$prefix.$golden');
172
  }
173 174
}

175 176
/// A [FlutterGoldenFileComparator] for testing golden images with Skia Gold in
/// post-submit.
177
///
178
/// For testing across all platforms, the [SkiaGoldClient] is used to upload
179
/// images for framework-related golden tests and process results.
180 181 182 183 184
///
/// See also:
///
///  * [GoldenFileComparator], the abstract class that
///    [FlutterGoldenFileComparator] implements.
185 186 187 188 189 190
///  * [FlutterPreSubmitFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images before changes are
///    merged into the master branch.
///  * [FlutterLocalFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images locally on your
///    current machine.
191 192
class FlutterPostSubmitFileComparator extends FlutterGoldenFileComparator {
  /// Creates a [FlutterPostSubmitFileComparator] that will test golden file
193
  /// images against Skia Gold.
194
  ///
195 196
  /// The [fs] and [platform] parameters are useful in tests, where the default
  /// file system and platform can be replaced by mock instances.
197
  FlutterPostSubmitFileComparator(
198 199 200 201
    final Uri basedir,
    final SkiaGoldClient skiaClient, {
    final FileSystem fs = const LocalFileSystem(),
    final Platform platform = const LocalPlatform(),
202 203
  }) : super(
    basedir,
204
    skiaClient,
205 206 207 208
    fs: fs,
    platform: platform,
  );

209
  /// Creates a new [FlutterPostSubmitFileComparator] that mirrors the relative
210
  /// path resolution of the default [goldenFileComparator].
211 212
  ///
  /// The [goldens] and [defaultComparator] parameters are visible for testing
213
  /// purposes only.
214
  static Future<FlutterPostSubmitFileComparator> fromDefaultComparator(
215
    final Platform platform, {
216 217
    SkiaGoldClient? goldens,
    LocalFileComparator? defaultComparator,
218
  }) async {
219

220
    defaultComparator ??= goldenFileComparator as LocalFileComparator;
221 222 223
    final Directory baseDirectory = FlutterGoldenFileComparator.getBaseDirectory(
      defaultComparator,
      platform,
224
      suffix: 'flutter_goldens_postsubmit.',
225
    );
226
    baseDirectory.createSync(recursive: true);
227

228
    goldens ??= SkiaGoldClient(baseDirectory);
229 230
    await goldens.auth();
    await goldens.imgtestInit();
231
    return FlutterPostSubmitFileComparator(baseDirectory.uri, goldens);
232 233 234 235
  }

  @override
  Future<bool> compare(Uint8List imageBytes, Uri golden) async {
236 237
    golden = _addPrefix(golden);
    await update(golden, imageBytes);
238
    final File goldenFile = getGoldenFile(golden);
239 240

    return skiaClient.imgtestAdd(golden.path, goldenFile);
241 242
  }

243 244
  /// Decides based on the current environment if goldens tests should be
  /// executed through Skia Gold.
245
  static bool isAvailableForEnvironment(Platform platform) {
246 247 248 249 250
    final bool luciPostSubmit = platform.environment.containsKey('SWARMING_TASK_ID')
      && platform.environment.containsKey('GOLDCTL')
      // Luci tryjob environments contain this value to inform the [FlutterPreSubmitComparator].
      && !platform.environment.containsKey('GOLD_TRYJOB');

251
    return luciPostSubmit;
252
  }
253 254
}

255
/// A [FlutterGoldenFileComparator] for testing golden images before changes are
256 257
/// merged into the master branch. The comparator executes tryjobs using the
/// [SkiaGoldClient].
258 259 260 261 262
///
/// See also:
///
///  * [GoldenFileComparator], the abstract class that
///    [FlutterGoldenFileComparator] implements.
263
///  * [FlutterPostSubmitFileComparator], another
264
///    [FlutterGoldenFileComparator] that uploads tests to the Skia Gold
265
///    dashboard in post-submit.
266 267 268 269 270 271
///  * [FlutterLocalFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images locally on your
///    current machine.
class FlutterPreSubmitFileComparator extends FlutterGoldenFileComparator {
  /// Creates a [FlutterPreSubmitFileComparator] that will test golden file
  /// images against baselines requested from Flutter Gold.
272
  ///
273 274 275
  /// The [fs] and [platform] parameters are useful in tests, where the default
  /// file system and platform can be replaced by mock instances.
  FlutterPreSubmitFileComparator(
276
    final Uri basedir,
277 278 279
    final SkiaGoldClient skiaClient, {
    final FileSystem fs = const LocalFileSystem(),
    final Platform platform = const LocalPlatform(),
280 281
  }) : super(
    basedir,
282
    skiaClient,
283 284 285 286
    fs: fs,
    platform: platform,
  );

287 288
  /// Creates a new [FlutterPreSubmitFileComparator] that mirrors the
  /// relative path resolution of the default [goldenFileComparator].
289 290 291
  ///
  /// The [goldens] and [defaultComparator] parameters are visible for testing
  /// purposes only.
292 293
  static Future<FlutterGoldenFileComparator> fromDefaultComparator(
    final Platform platform, {
294 295 296
    SkiaGoldClient? goldens,
    LocalFileComparator? defaultComparator,
    Directory? testBasedir,
297
  }) async {
298

299
    defaultComparator ??= goldenFileComparator as LocalFileComparator;
300
    final Directory baseDirectory = testBasedir ?? FlutterGoldenFileComparator.getBaseDirectory(
301 302
      defaultComparator,
      platform,
303
      suffix: 'flutter_goldens_presubmit.',
304
    );
305 306 307

    if (!baseDirectory.existsSync())
      baseDirectory.createSync(recursive: true);
308

309
    goldens ??= SkiaGoldClient(baseDirectory);
310

311 312 313
    await goldens.auth();
    await goldens.tryjobInit();
      return FlutterPreSubmitFileComparator(
314 315 316 317 318 319 320 321 322 323 324 325
        baseDirectory.uri,
        goldens,
        platform: platform,
      );
    }

  @override
  Future<bool> compare(Uint8List imageBytes, Uri golden) async {
    golden = _addPrefix(golden);
    await update(golden, imageBytes);
    final File goldenFile = getGoldenFile(golden);

326 327 328 329 330
    await skiaClient.tryjobAdd(golden.path, goldenFile);

    // This will always return true since golden file test failures are managed
    // in pre-submit checks by the flutter-gold status check.
    return true;
331 332
  }

333 334 335 336 337 338 339
  /// Decides based on the current environment if goldens tests should be
  /// executed as pre-submit tests with Skia Gold.
  static bool isAvailableForEnvironment(Platform platform) {
    final bool luciPreSubmit = platform.environment.containsKey('SWARMING_TASK_ID')
      && platform.environment.containsKey('GOLDCTL')
      && platform.environment.containsKey('GOLD_TRYJOB');
    return luciPreSubmit;
340 341 342
  }
}

343 344
/// A [FlutterGoldenFileComparator] for testing conditions that do not execute
/// golden file tests.
345
///
346 347
/// Currently, this comparator is used on Cirrus, or in Luci environments when executing tests
/// outside of the flutter/flutter repository.
348 349 350
///
/// See also:
///
351
///  * [FlutterPostSubmitFileComparator], another [FlutterGoldenFileComparator]
352 353 354 355 356 357 358
///    that tests golden images through Skia Gold.
///  * [FlutterPreSubmitFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images before changes are
///    merged into the master branch.
///  * [FlutterLocalFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images locally on your
///    current machine.
359 360
class FlutterSkippingFileComparator extends FlutterGoldenFileComparator {
  /// Creates a [FlutterSkippingFileComparator] that will skip tests that
361
  /// are not in the right environment for golden file testing.
362
  FlutterSkippingFileComparator(
363 364
    final Uri basedir,
    final SkiaGoldClient skiaClient,
365
    this.reason,
366
  ) : super(basedir, skiaClient);
367

368
  /// Describes the reason for using the [FlutterSkippingFileComparator].
369 370 371
  ///
  /// Cannot be null.
  final String reason;
372

373
  /// Creates a new [FlutterSkippingFileComparator] that mirrors the
374
  /// relative path resolution of the default [goldenFileComparator].
375
  static FlutterSkippingFileComparator fromDefaultComparator(
376
    String reason, {
377
    LocalFileComparator? defaultComparator,
378
  }) {
379
    defaultComparator ??= goldenFileComparator as LocalFileComparator;
380 381
    const FileSystem fs = LocalFileSystem();
    final Uri basedir = defaultComparator.basedir;
382
    final SkiaGoldClient skiaClient = SkiaGoldClient(fs.directory(basedir));
383
    return FlutterSkippingFileComparator(basedir, skiaClient, reason);
384 385 386 387 388
  }

  @override
  Future<bool> compare(Uint8List imageBytes, Uri golden) async {
    print(
389
      'Skipping "$golden" test : $reason'
390 391 392 393 394
    );
    return true;
  }

  @override
395
  Future<void> update(Uri golden, Uint8List imageBytes) async {}
396

397
  /// Decides, based on the current environment, if this comparator should be
398
  /// used.
399
  ///
400
  /// If we are in a CI environment, LUCI or Cirrus, but are not using the other
401
  /// comparators, we skip.
402
  static bool isAvailableForEnvironment(Platform platform) {
403
    return platform.environment.containsKey('SWARMING_TASK_ID')
404
      // Some builds are still being run on Cirrus, we should skip these.
405
      || platform.environment.containsKey('CIRRUS_CI');
406
  }
407
}
408

409 410 411 412
/// A [FlutterGoldenFileComparator] for testing golden images locally on your
/// current machine.
///
/// This comparator utilizes the [SkiaGoldClient] to request baseline images for
413 414 415 416 417 418 419 420
/// the given device under test for comparison. This comparator is initialized
/// when conditions for all other [FlutterGoldenFileComparators] have not been
/// met, see the `isAvailableForEnvironment` method for each one listed below.
///
/// The [FlutterLocalFileComparator] is intended to run on local machines and
/// serve as a smoke test during development. As such, it will not be able to
/// detect unintended changes on environments other than the currently executing
/// machine, until they are tested using the [FlutterPreSubmitFileComparator].
421 422 423 424 425
///
/// See also:
///
///  * [GoldenFileComparator], the abstract class that
///    [FlutterGoldenFileComparator] implements.
426
///  * [FlutterPostSubmitFileComparator], another
427 428 429 430 431
///    [FlutterGoldenFileComparator] that uploads tests to the Skia Gold
///    dashboard.
///  * [FlutterPreSubmitFileComparator], another
///    [FlutterGoldenFileComparator] that tests golden images before changes are
///    merged into the master branch.
432
///  * [FlutterSkippingFileComparator], another
433 434
///    [FlutterGoldenFileComparator] that controls post-submit testing
///    conditions that do not execute golden file tests.
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
class FlutterLocalFileComparator extends FlutterGoldenFileComparator with LocalComparisonOutput {
  /// Creates a [FlutterLocalFileComparator] that will test golden file
  /// images against baselines requested from Flutter Gold.
  ///
  /// The [fs] and [platform] parameters are useful in tests, where the default
  /// file system and platform can be replaced by mock instances.
  FlutterLocalFileComparator(
    final Uri basedir,
    final SkiaGoldClient skiaClient, {
    final FileSystem fs = const LocalFileSystem(),
    final Platform platform = const LocalPlatform(),
  }) : super(
    basedir,
    skiaClient,
    fs: fs,
    platform: platform,
  );

  /// Creates a new [FlutterLocalFileComparator] that mirrors the
  /// relative path resolution of the default [goldenFileComparator].
  ///
456 457
  /// The [goldens], [defaultComparator], and [baseDirectory] parameters are
  /// visible for testing purposes only.
458 459
  static Future<FlutterGoldenFileComparator> fromDefaultComparator(
    final Platform platform, {
460 461 462
    SkiaGoldClient? goldens,
    LocalFileComparator? defaultComparator,
    Directory? baseDirectory,
463
  }) async {
464
    defaultComparator ??= goldenFileComparator as LocalFileComparator;
465
    baseDirectory ??= FlutterGoldenFileComparator.getBaseDirectory(
466 467 468 469 470 471 472 473
      defaultComparator,
      platform,
    );

    if(!baseDirectory.existsSync()) {
      baseDirectory.createSync(recursive: true);
    }

474
    goldens ??= SkiaGoldClient(baseDirectory);
475
    try {
476 477
      // Check if we can reach Gold.
      await goldens.getExpectationForTest('');
478
    } on io.OSError catch (_) {
479
      return FlutterSkippingFileComparator(
480 481
        baseDirectory.uri,
        goldens,
482 483 484 485
        'OSError occurred, could not reach Gold. '
          'Switching to FlutterSkippingGoldenFileComparator.',
      );
    } on io.SocketException catch (_) {
486
      return FlutterSkippingFileComparator(
487 488 489 490
        baseDirectory.uri,
        goldens,
        'SocketException occurred, could not reach Gold. '
          'Switching to FlutterSkippingGoldenFileComparator.',
491 492
      );
    }
493 494 495 496 497 498 499 500

    return FlutterLocalFileComparator(baseDirectory.uri, goldens);
  }

  @override
  Future<bool> compare(Uint8List imageBytes, Uri golden) async {
    golden = _addPrefix(golden);
    final String testName = skiaClient.cleanTestName(golden.path);
501 502 503
    late String? testExpectation;
    testExpectation = await skiaClient.getExpectationForTest(testName);

504
    if (testExpectation == null || testExpectation.isEmpty) {
505 506 507 508 509 510 511 512 513 514 515
      // There is no baseline for this test
      print('No expectations provided by Skia Gold for test: $golden. '
        'This may be a new test. If this is an unexpected result, check '
        'https://flutter-gold.skia.org.\n'
        'Validate image output found at $basedir'
      );
      update(golden, imageBytes);
      return true;
    }

    ComparisonResult result;
516
    final List<int> goldenBytes = await skiaClient.getImageBytes(testExpectation);
517

518 519 520 521
    result = await GoldenFileComparator.compareLists(
      imageBytes,
      goldenBytes,
    );
522

523 524
    if (result.passed)
      return true;
525

526 527
    final String error = await generateFailureOutput(result, golden, basedir);
    throw FlutterError(error);
528 529
  }
}