[builder] Port results processing from cloud functions to script
This CL changes the result processing to a single script that uses
the firestore REST API to update the results for a build in a single
run, instead of processing multiple chunks in cloud functions.
Change-Id: Ic4cec086e5a167c58b8624de18fab17eaca271e3
Reviewed-on: https://dart-review.googlesource.com/c/dart_ci/+/203220
Reviewed-by: William Hesse <whesse@google.com>
diff --git a/builder/.gitignore b/builder/.gitignore
new file mode 100644
index 0000000..3c8a157
--- /dev/null
+++ b/builder/.gitignore
@@ -0,0 +1,6 @@
+# Files and directories created by pub.
+.dart_tool/
+.packages
+
+# Conventional directory for build output.
+build/
diff --git a/builder/analysis_options.yaml b/builder/analysis_options.yaml
new file mode 100644
index 0000000..5cc08da
--- /dev/null
+++ b/builder/analysis_options.yaml
@@ -0,0 +1,5 @@
+# Defines a default set of lint rules enforced for projects at Google. For
+# details and rationale, see
+# https://github.com/dart-lang/pedantic#enabled-lints.
+
+include: package:pedantic/analysis_options.yaml
diff --git a/builder/bin/update_results_database.dart b/builder/bin/update_results_database.dart
new file mode 100644
index 0000000..a6e5a15
--- /dev/null
+++ b/builder/bin/update_results_database.dart
@@ -0,0 +1,87 @@
+// @dart = 2.9
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:builder/src/builder.dart';
+import 'package:builder/src/commits_cache.dart';
+import 'package:builder/src/firestore.dart';
+import 'package:builder/src/result.dart';
+import 'package:builder/src/tryjob.dart';
+import 'package:googleapis/firestore/v1.dart';
+import 'package:googleapis_auth/auth_io.dart';
+import 'package:http/http.dart' as http;
+
+// TODO(karlklose): Convert to streaming
+// Stream<Map> readChangedResults(File resultsFile) {
+// return resultsFile.openRead()
+// .transform(utf8.decoder) // Decode bytes to UTF-8.
+// .transform(LineSplitter())
+// .map((line) => jsonDecode as Map)
+// .where((result) => result['changed']);
+// }
+Future<List<Map<String, dynamic>>> readChangedResults(File resultsFile) async {
+ return (await resultsFile.readAsLines())
+ .map((line) => jsonDecode(line) as Map<String, dynamic>)
+ .where(isChangedResult)
+ .toList();
+}
+
+File fileOption(options, String name) {
+ final path = options[name];
+ if (path == null) {
+ print("Required option '$name'!");
+ exit(1);
+ }
+ final file = File(path);
+ if (!file.existsSync()) {
+ print('File not found: "$path"');
+ exit(1);
+ }
+ return file;
+}
+
+Future<void> processResults(options, client, firestore) async {
+ final project = options['project'] as String;
+ // TODO(karlklose): remove this when switching to production.
+ if (project != 'dart-ci-staging') throw 'Unuspported mode';
+ final inputFile = fileOption(options, 'results');
+ final results = await readChangedResults(inputFile);
+ if (results.isNotEmpty) {
+ final first = results.first;
+ final String commit = first['commit_hash'];
+ final String buildbucketID = options['buildbucket_id'];
+ final String baseRevision = options['base_revision'];
+ final commitCache = CommitsCache(firestore, client);
+ final process = commit.startsWith('refs/changes')
+ ? Tryjob(commit, buildbucketID, baseRevision, commitCache, firestore,
+ client)
+ .process
+ : Build(commit, first, commitCache, firestore).process;
+ await process(results);
+ }
+}
+
+void main(List<String> arguments) async {
+ final options = (ArgParser()
+ ..addOption('project',
+ abbr: 'p',
+ defaultsTo: 'dart-ci-staging',
+ allowed: ['dart-ci-staging'])
+ ..addOption('results', abbr: 'r')
+ ..addOption('buildbucket_id', abbr: 'i')
+ ..addOption('base_revision', abbr: 'b'))
+ .parse(arguments);
+
+ final baseClient = http.Client();
+ final client = await clientViaApplicationDefaultCredentials(
+ scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+ baseClient: baseClient);
+ final api = FirestoreApi(client);
+ final firestore = FirestoreService(api, client);
+
+ await processResults(options, client, firestore);
+
+ baseClient.close();
+}
diff --git a/builder/lib/src/builder.dart b/builder/lib/src/builder.dart
new file mode 100644
index 0000000..46d1d79
--- /dev/null
+++ b/builder/lib/src/builder.dart
@@ -0,0 +1,213 @@
+// 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.
+
+import 'package:pool/pool.dart';
+
+import 'commits_cache.dart';
+import 'firestore.dart';
+import 'result.dart';
+import 'reverted_changes.dart';
+import 'tryjob.dart' show Tryjob;
+
+/// A Builder holds information about a CI build, and can
+/// store the changed results from that build, using an injected
+/// [FirestoreService] object.
+/// Tryjob builds are represented by the class [Tryjob] instead.
+class Build {
+ final FirestoreService firestore;
+ final CommitsCache commitsCache;
+ final String commitHash;
+ final Map<String, dynamic> firstResult;
+ String builderName;
+ int buildNumber;
+ int startIndex;
+ int endIndex;
+ Commit endCommit;
+ List<Commit> commits;
+ Map<String, int> tryApprovals = {};
+ List<RevertedChanges> allRevertedChanges = [];
+
+ bool success = true; // Changed to false if any unapproved failure is seen.
+ int countChanges = 0;
+ int commitsFetched;
+ List<String> approvalMessages = [];
+ int countApprovalsCopied = 0;
+
+ Build(this.commitHash, this.firstResult, this.commitsCache, this.firestore)
+ : builderName = firstResult['builder_name'],
+ buildNumber = int.parse(firstResult['build_number']);
+
+ void log(String string) => firestore.log(string);
+
+ Future<void> process(List<Map<String, dynamic>> results) async {
+ log('store build commits info');
+ await storeBuildCommitsInfo();
+ log('update build info');
+ if (!await firestore.updateBuildInfo(builderName, buildNumber, endIndex)) {
+ // This build's results have already been recorded.
+ log('build up-to-date, exiting');
+ // TODO(karlklose): add a flag to overwrite builder results.
+ return;
+ }
+ final configurations =
+ results.map((change) => change['configuration'] as String).toSet();
+ log('updating configurations');
+ await update(configurations);
+ final changes = results.where(isChangedResult);
+ log('storing ${changes.length} change(s)');
+ var count = 0;
+ await Pool(30).forEach(changes, (change) async {
+ await storeChange(change);
+ if (++count % 50 == 0) {
+ log('Processed $count changes...');
+ }
+ }).drain();
+ log('complete builder record');
+ await firestore.completeBuilderRecord(builderName, endIndex, success);
+
+ final report = [
+ 'Processed ${results.length} results from $builderName build $buildNumber',
+ if (countChanges > 0) 'Stored $countChanges changes',
+ if (commitsFetched != null) 'Fetched $commitsFetched new commits',
+ '${firestore.documentsFetched} documents fetched',
+ '${firestore.documentsWritten} documents written',
+ if (!success) 'Found unapproved new failures',
+ if (countApprovalsCopied > 0) ...[
+ '$countApprovalsCopied approvals copied',
+ ...approvalMessages,
+ if (countApprovalsCopied > 10) '...'
+ ]
+ ];
+ log(report.join('\n'));
+ }
+
+ Future<void> update(Iterable<String> configurations) async {
+ await storeConfigurationsInfo(configurations);
+ }
+
+ /// Stores the commit info for the blamelist of result.
+ /// If the info is already there does nothing.
+ /// Saves the commit indices of the start and end of the blamelist.
+ Future<void> storeBuildCommitsInfo() async {
+ // Get indices of change. Range includes startIndex and endIndex.
+ endCommit = await commitsCache.getCommit(commitHash);
+ if (endCommit == null) {
+ throw 'Result received with unknown commit hash $commitHash';
+ }
+ endIndex = endCommit.index;
+ // If this is a new builder, use the current commit as a trivial blamelist.
+ if (firstResult['previous_commit_hash'] == null) {
+ startIndex = endIndex;
+ } else {
+ final startCommit =
+ await commitsCache.getCommit(firstResult['previous_commit_hash']);
+ startIndex = startCommit.index + 1;
+ if (startIndex > endIndex) {
+ throw ArgumentError('Results received with empty blamelist\n'
+ 'previous commit: ${firstResult['previous_commit_hash']}\n'
+ 'built commit: $commitHash');
+ }
+ }
+ }
+
+ /// This async function's implementation runs exactly once.
+ /// Later invocations return the same future returned by the first invocation.
+ Future<void> fetchReviewsAndReverts() async {
+ commits = [
+ for (var index = startIndex; index < endIndex; ++index)
+ await commitsCache.getCommitByIndex(index),
+ endCommit
+ ];
+ for (final commit in commits) {
+ final index = commit.index;
+ final review = commit.review;
+ final reverted = commit.revertOf;
+ if (review != null) {
+ tryApprovals.addAll({
+ for (final result in await firestore.tryApprovals(review))
+ testResult(result): index
+ });
+ }
+ if (reverted != null) {
+ allRevertedChanges
+ .add(await getRevertedChanges(reverted, index, firestore));
+ }
+ }
+ }
+
+ Future<void> storeConfigurationsInfo(Iterable<String> configurations) async {
+ for (final configuration in configurations) {
+ await firestore.updateConfiguration(configuration, builderName);
+ }
+ }
+
+ Future<void> storeChange(Map<String, dynamic> change) async {
+ countChanges++;
+ await fetchReviewsAndReverts();
+ transformChange(change);
+ final failure = isFailure(change);
+ var approved;
+ var result = await firestore.findResult(change, startIndex, endIndex);
+ var activeResults = await firestore.findActiveResults(
+ change['name'], change['configuration']);
+ if (result == null) {
+ final approvingIndex = tryApprovals[testResult(change)] ??
+ allRevertedChanges
+ .firstWhere(
+ (revertedChange) => revertedChange.approveRevert(change),
+ orElse: () => null)
+ ?.revertIndex;
+ approved = approvingIndex != null;
+ final newResult = constructResult(change, startIndex, endIndex,
+ approved: approved,
+ landedReviewIndex: approvingIndex,
+ failure: failure);
+ await firestore.storeResult(newResult);
+ if (approved) {
+ countApprovalsCopied++;
+ if (countApprovalsCopied <= 10) {
+ approvalMessages
+ .add('Copied approval of result ${testResult(change)}');
+ }
+ }
+ } else {
+ approved = await firestore.updateResult(
+ result, change['configuration'], startIndex, endIndex,
+ failure: failure);
+ }
+ if (failure && !approved) success = false;
+
+ for (final activeResult in activeResults) {
+ final resultRecord = ResultRecord(activeResult.fields);
+ // Log error message if any expected invariants are violated
+ if (resultRecord.blamelistEndIndex >= startIndex ||
+ !resultRecord.containsActiveConfiguration(change['configuration'])) {
+ // log('Unexpected active result when processing new change:\n'
+ // 'Active result: ${untagMap(activeResult.fields)}\n\n'
+ // 'Change: $change\n\n'
+ // 'approved: $approved');
+ }
+ // Removes the configuration from the list of active configurations.
+ await firestore.updateActiveResult(activeResult, change['configuration']);
+ }
+ }
+}
+
+Map<String, dynamic> constructResult(
+ Map<String, dynamic> change, int startIndex, int endIndex,
+ {bool approved, int landedReviewIndex, bool failure}) {
+ return {
+ fName: change[fName],
+ fResult: change[fResult],
+ fPreviousResult: change[fPreviousResult],
+ fExpected: change[fExpected],
+ fBlamelistStartIndex: startIndex,
+ fBlamelistEndIndex: endIndex,
+ if (startIndex != endIndex && approved) fPinnedIndex: landedReviewIndex,
+ fConfigurations: <String>[change['configuration']],
+ fApproved: approved,
+ if (failure) fActive: true,
+ if (failure) fActiveConfigurations: <String>[change['configuration']]
+ };
+}
diff --git a/builder/lib/src/commits_cache.dart b/builder/lib/src/commits_cache.dart
new file mode 100644
index 0000000..2f98b31
--- /dev/null
+++ b/builder/lib/src/commits_cache.dart
@@ -0,0 +1,232 @@
+// Copyright (c) 2020, 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:convert';
+
+import 'package:http/http.dart' as http;
+import 'firestore.dart';
+import 'result.dart';
+
+/// Contains data about the commits on the tracked branch of the SDK repo.
+/// An instance of this class is stored in a top-level variable, and is
+/// shared between cloud function invocations.
+///
+/// The class fetches commits from Firestore if they are present,
+/// and fetches them from gitiles if not, and saves them to Firestore.
+class CommitsCache {
+ FirestoreService firestore;
+ final http.Client httpClient;
+ Map<String, Commit> byHash = {};
+ Map<int, Commit> byIndex = {};
+ int startIndex;
+ int endIndex;
+
+ CommitsCache(this.firestore, this.httpClient);
+
+ Future<Commit> getCommit(String hash) async {
+ return byHash[hash] ??
+ await _fetchByHash(hash) ??
+ await _getNewCommits() ??
+ await _fetchByHash(hash) ??
+ _reportError('getCommit($hash)');
+ }
+
+ Future<Commit> getCommitByIndex(int index) async {
+ return byIndex[index] ??
+ await _fetchByIndex(index) ??
+ await _getNewCommits() ??
+ await _fetchByIndex(index) ??
+ _reportError('getCommitByIndex($index)');
+ }
+
+ Commit _reportError(String message) {
+ final error = 'Failed to fetch commit: $message\n'
+ 'Commit cache holds:\n'
+ ' $startIndex: ${byIndex[startIndex]}\n'
+ ' ...\n'
+ ' $endIndex: ${byIndex[endIndex]}';
+ print(error);
+ throw error;
+ }
+
+ /// Add a commit to the cache. The cache must be empty, or the commit
+ /// must be immediately before or after the current cached commits.
+ /// Otherwise, do nothing.
+ void _cacheCommit(Commit commit) {
+ final index = commit.index;
+ if (startIndex == null || startIndex == index + 1) {
+ startIndex = index;
+ endIndex ??= index;
+ } else if (endIndex + 1 == index) {
+ endIndex = index;
+ } else {
+ return;
+ }
+ byHash[commit.hash] = commit;
+ byIndex[index] = commit;
+ }
+
+ Future<Commit> _fetchByHash(String hash) async {
+ final commit = await firestore.getCommit(hash);
+ if (commit == null) return null;
+ final index = commit.index;
+ if (startIndex == null) {
+ _cacheCommit(commit);
+ } else if (index < startIndex) {
+ for (var fetchIndex = startIndex - 1; fetchIndex > index; --fetchIndex) {
+ // Other invocations may be fetching simultaneously.
+ if (fetchIndex < startIndex) {
+ final infillCommit = await firestore.getCommitByIndex(fetchIndex);
+ _cacheCommit(infillCommit);
+ }
+ }
+ _cacheCommit(commit);
+ } else if (index > endIndex) {
+ for (var fetchIndex = endIndex + 1; fetchIndex < index; ++fetchIndex) {
+ // Other invocations may be fetching simultaneously.
+ if (fetchIndex > endIndex) {
+ final infillCommit = await firestore.getCommitByIndex(fetchIndex);
+ _cacheCommit(infillCommit);
+ }
+ }
+ _cacheCommit(commit);
+ }
+ return commit;
+ }
+
+ Future<Commit> _fetchByIndex(int index) => firestore
+ .getCommitByIndex(index)
+ .then((commit) => _fetchByHash(commit.hash));
+
+ /// This function is idempotent, so every call of it should write the
+ /// same info to new Firestore documents. It is safe to call multiple
+ /// times simultaneously.
+ Future<Null> _getNewCommits() async {
+ const prefix = ")]}'\n";
+ final lastCommit = await firestore.getLastCommit();
+ final lastHash = lastCommit.hash;
+ final lastIndex = lastCommit.index;
+
+ final branch = 'master';
+ final logUrl = 'https://dart.googlesource.com/sdk/+log/';
+ final range = '$lastHash..$branch';
+ final parameters = ['format=JSON', 'topo-order', 'first-parent', 'n=1000'];
+ final url = '$logUrl$range?${parameters.join('&')}';
+ final response = await httpClient.get(url);
+ final protectedJson = response.body;
+ if (!protectedJson.startsWith(prefix)) {
+ throw Exception('Gerrit response missing prefix $prefix: $protectedJson.'
+ 'Requested URL: $url');
+ }
+ final commits = jsonDecode(protectedJson.substring(prefix.length))['log']
+ as List<dynamic>;
+ if (commits.isEmpty) {
+ print('Found no new commits between $lastHash and $branch');
+ return;
+ }
+ print('Fetched new commits from Gerrit (gitiles): $commits');
+ final first = commits.last as Map<String, dynamic>;
+ if (first['parents'].first != lastHash) {
+ throw 'First new commit ${first['commit']} is not'
+ ' a child of last known commit $lastHash when fetching new commits';
+ }
+ var index = lastIndex + 1;
+ for (Map<String, dynamic> commit in commits.reversed) {
+ final review = _review(commit);
+ var reverted = _revert(commit);
+ var relanded = _reland(commit);
+ if (relanded != null) {
+ reverted = null;
+ }
+ if (reverted != null) {
+ final revertedCommit = await firestore.getCommit(reverted);
+ if (revertedCommit != null && revertedCommit.isRevert) {
+ reverted = null;
+ relanded = revertedCommit.revertOf;
+ }
+ }
+ await firestore.addCommit(commit['commit'], {
+ fAuthor: commit['author']['email'],
+ fCreated: parseGitilesDateTime(commit['committer']['time']),
+ fIndex: index,
+ fTitle: commit['message'].split('\n').first,
+ if (review != null) fReview: review,
+ if (reverted != null) fRevertOf: reverted,
+ if (relanded != null) fRelandOf: relanded,
+ });
+ if (review != null) {
+ await landReview(commit, index);
+ }
+ ++index;
+ }
+ }
+
+ /// This function is idempotent and may be called multiple times
+ /// concurrently.
+ Future<void> landReview(Map<String, dynamic> commit, int index) async {
+ final review = _review(commit);
+ // Optimization to avoid duplicate work: if another instance has linked
+ // the review to its landed commit, do nothing.
+ if (await firestore.reviewIsLanded(review)) return;
+ await firestore.linkReviewToCommit(review, index);
+ await firestore.linkCommentsToCommit(review, index);
+ }
+}
+
+class TestingCommitsCache extends CommitsCache {
+ TestingCommitsCache(firestore, httpClient) : super(firestore, httpClient);
+
+ @override
+ Future<Null> _getNewCommits() async {
+ if ((await firestore.isStaging())) {
+ return super._getNewCommits();
+ }
+ }
+}
+
+const months = {
+ 'Jan': '01',
+ 'Feb': '02',
+ 'Mar': '03',
+ 'Apr': '04',
+ 'May': '05',
+ 'Jun': '06',
+ 'Jul': '07',
+ 'Aug': '08',
+ 'Sep': '09',
+ 'Oct': '10',
+ 'Nov': '11',
+ 'Dec': '12'
+};
+
+DateTime parseGitilesDateTime(String gitiles) {
+ final parts = gitiles.split(' ');
+ final year = parts[4];
+ final month = months[parts[1]];
+ final day = parts[2].padLeft(2, '0');
+ return DateTime.parse('$year-$month-$day ${parts[3]} ${parts[5]}');
+}
+
+final reviewRegExp = RegExp(
+ '^Reviewed-on: https://dart-review.googlesource.com/c/sdk/\\+/(\\d+)\$',
+ multiLine: true);
+
+int _review(Map<String, dynamic> commit) {
+ final match = reviewRegExp.firstMatch(commit['message']);
+ if (match != null) return int.parse(match.group(1));
+ return null;
+}
+
+final revertRegExp =
+ RegExp('^This reverts commit ([\\da-f]+)\\.\$', multiLine: true);
+
+String _revert(Map<String, dynamic> commit) =>
+ revertRegExp.firstMatch(commit['message'])?.group(1);
+
+final relandRegExp =
+ RegExp('^This is a reland of ([\\da-f]+)\\.?\$', multiLine: true);
+
+String _reland(Map<String, dynamic> commit) =>
+ relandRegExp.firstMatch(commit['message'])?.group(1);
diff --git a/builder/lib/src/firestore.dart b/builder/lib/src/firestore.dart
new file mode 100644
index 0000000..40c981b
--- /dev/null
+++ b/builder/lib/src/firestore.dart
@@ -0,0 +1,856 @@
+// 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.
+
+import 'dart:convert';
+import 'dart:io';
+import 'dart:math' show max, min;
+import 'package:builder/src/result.dart';
+import 'package:googleapis/firestore/v1.dart';
+import 'package:http/http.dart' as http;
+
+class ResultRecord {
+ final Map<String, Value> fields;
+
+ ResultRecord(this.fields);
+
+ bool get approved => fields['approved'].booleanValue;
+
+ @override
+ String toString() => jsonEncode(fields);
+
+ int get blamelistEndIndex {
+ return int.parse(fields['blamelist_end_index'].integerValue);
+ }
+
+ bool containsActiveConfiguration(String configuration) {
+ for (final value in fields['active_configurations'].arrayValue.values) {
+ if (value.stringValue != null && value.stringValue == configuration) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
+
+Map<String, Value> taggedMap(Map<String, dynamic> fields) {
+ return fields.map((key, value) => MapEntry(key, taggedValue(value)));
+}
+
+Value taggedValue(dynamic value) {
+ if (value is int) {
+ return Value()..integerValue = '$value';
+ } else if (value is String) {
+ return Value()..stringValue = value;
+ } else if (value is bool) {
+ return Value()..booleanValue = value;
+ } else if (value is DateTime) {
+ return Value()..timestampValue = value.toUtc().toIso8601String();
+ } else if (value is List) {
+ return Value()
+ ..arrayValue = (ArrayValue()
+ ..values = value.map((element) => taggedValue(element)).toList());
+ } else if (value == null) {
+ return Value()..nullValue = 'NULL_VALUE';
+ } else {
+ throw Exception('unsupported value type ${value.runtimeType}');
+ }
+}
+
+dynamic getValue(Value value) {
+ if (value.integerValue != null) {
+ return int.parse(value.integerValue);
+ } else if (value.stringValue != null) {
+ return value.stringValue;
+ } else if (value.booleanValue != null) {
+ return value.booleanValue;
+ } else if (value.arrayValue != null) {
+ return value.arrayValue.values.map(getValue).toList();
+ } else if (value.timestampValue != null) {
+ return DateTime.parse(value.timestampValue);
+ }
+ throw Exception('unsupported value ${value.toJson()}');
+}
+
+/// Converts a map with normal Dart values to a map where the values are
+/// JSON representation of firestore API values. For example: `{'x': 3}` is
+/// translated to `{'x': {'integerValue': 3}}`.
+Map<String, Object> taggedJsonMap(Map<String, dynamic> fields) {
+ return fields.map((key, value) => MapEntry(key, taggedValue(value).toJson()));
+}
+
+Map<String, dynamic> untagMap(Map<String, Value> map) {
+ return map.map((key, value) => MapEntry(key, getValue(value)));
+}
+
+List<CollectionSelector> inCollection(String name) {
+ return [CollectionSelector()..collectionId = name];
+}
+
+FieldReference field(String name) {
+ return FieldReference()..fieldPath = name;
+}
+
+Order orderBy(String fieldName, bool ascending) {
+ return Order()
+ ..field = field(fieldName)
+ ..direction = ascending ? 'ASCENDING' : 'DESCENDING';
+}
+
+Filter fieldEquals(String fieldName, dynamic value) {
+ return Filter()
+ ..fieldFilter = (FieldFilter()
+ ..field = field(fieldName)
+ ..op = 'EQUAL'
+ ..value = taggedValue(value));
+}
+
+Filter fieldLessThanOrEqual(String fieldName, dynamic value) {
+ return Filter()
+ ..fieldFilter = (FieldFilter()
+ ..field = field(fieldName)
+ ..op = 'LESS_THAN_OR_EQUAL'
+ ..value = taggedValue(value));
+}
+
+Filter fieldGreaterThanOrEqual(String fieldName, dynamic value) {
+ return Filter()
+ ..fieldFilter = (FieldFilter()
+ ..field = field(fieldName)
+ ..op = 'GREATER_THAN_OR_EQUAL'
+ ..value = taggedValue(value));
+}
+
+Filter arrayContains(String fieldName, dynamic value) {
+ return Filter()
+ ..fieldFilter = (FieldFilter()
+ ..field = field(fieldName)
+ ..op = 'ARRAY_CONTAINS'
+ ..value = taggedValue(value));
+}
+
+Filter compositeFilter(List<Filter> filters) {
+ return Filter()
+ ..compositeFilter = (CompositeFilter()
+ ..filters = filters
+ ..op = 'AND');
+}
+
+class DataWrapper {
+ final Map<String, Value> fields;
+ DataWrapper(Document document) : fields = document.fields;
+ DataWrapper.fields(this.fields);
+ int getInt(String name) {
+ final value = fields[name]?.integerValue;
+ if (value == null) {
+ return null;
+ }
+ return int.parse(value);
+ }
+
+ String getString(String name) {
+ return fields[name]?.stringValue;
+ }
+
+ bool getBool(String name) {
+ return fields[name]?.booleanValue;
+ }
+
+ List<dynamic> getList(String name) {
+ return fields[name]?.arrayValue?.values?.map(getValue)?.toList();
+ }
+
+ bool isNull(String name) {
+ return !fields.containsKey(name) ||
+ fields['name'].nullValue == 'NULL_VALUE';
+ }
+}
+
+class Commit {
+ final DataWrapper wrapper;
+ final String hash;
+ Commit(this.hash, Document document) : wrapper = DataWrapper(document);
+ Commit.fromJson(this.hash, Map<String, dynamic> data)
+ : wrapper = DataWrapper.fields(taggedMap(data));
+ int get index => wrapper.getInt('index');
+ String get revertOf => wrapper.getString(fRevertOf);
+ bool get isRevert => wrapper.fields.containsKey(fRevertOf);
+ int get review => wrapper.getInt(fReview);
+
+ Map<String, Object> toJson() => untagMap(wrapper.fields);
+}
+
+class FirestoreService {
+ final String project;
+ final FirestoreApi firestore;
+ final http.Client client;
+ int documentsFetched = 0;
+ int documentsWritten = 0;
+
+ final Stopwatch _stopwatch;
+
+ FirestoreService(this.firestore, this.client,
+ {this.project = 'dart-ci-staging'})
+ : _stopwatch = Stopwatch()..start();
+
+ void log(String string) {
+ final time = _stopwatch.elapsed.toString();
+ final lines = LineSplitter().convert(string);
+ for (final line in lines) {
+ print('$time $line');
+ }
+ }
+
+ Future<List<RunQueryResponse>> query(
+ {String from,
+ Filter where,
+ Order orderBy,
+ int limit,
+ String parent}) async {
+ final query = StructuredQuery();
+ if (from != null) {
+ query.from = inCollection(from);
+ }
+ if (where != null) {
+ query.where = where;
+ }
+ if (orderBy != null) {
+ query.orderBy = [orderBy];
+ }
+ if (limit != null) {
+ query.limit = limit;
+ }
+ final responses = await runQuery(query, parent: parent);
+ // The REST API will respond with a single `null` result in case the query
+ // did not match any documents.
+ if (responses.length == 1 && responses.single.document == null) {
+ return [];
+ }
+ return responses;
+ }
+
+ Future<Document> getDocument(String path,
+ {bool throwOnNotFound = true}) async {
+ try {
+ final document = await firestore.projects.databases.documents.get(path);
+ documentsFetched++;
+ return document;
+ } on DetailedApiRequestError catch (e) {
+ if (!throwOnNotFound && e.status == 404) {
+ return null;
+ } else {
+ log("Failed to get document '$path'");
+ rethrow;
+ }
+ }
+ }
+
+ String get databaseUri {
+ return 'https://firestore.googleapis.com/v1/$database';
+ }
+
+ String get database => 'projects/$project/databases/(default)';
+ String get documents => '$database/documents';
+
+ Future<List<RunQueryResponse>> runQuery(StructuredQuery query,
+ {String parent}) async {
+ // This is a workaround for a bug in googleapis' generated runQuery implementation
+ // (https://github.com/google/googleapis.dart/issues/25).
+ final request = RunQueryRequest()..structuredQuery = query;
+ final parentPath = parent == null ? '' : '/$parent';
+ final queryString = '$databaseUri/documents$parentPath:runQuery';
+ final requestBody = jsonEncode(request.toJson());
+ final response =
+ await client.post(Uri.parse(queryString), body: requestBody);
+ if (response.statusCode == HttpStatus.ok) {
+ final results = jsonDecode(response.body) as List;
+ return results
+ .map((result) => RunQueryResponse.fromJson(result))
+ .toList();
+ }
+ final message = '${response.statusCode}: ${response.body}';
+ throw Exception('Query error:\nurl=$queryString:\nquery=$query\n$message');
+ }
+
+ Future<void> writeDocument(Document document) async {
+ documentsWritten++;
+ final request = CommitRequest()..writes = [Write()..update = document];
+ await firestore.projects.databases.documents.commit(request, database);
+ }
+
+ Future<bool> isStaging() => Future.value(project == 'dart-ci-staging');
+
+ Future<bool> hasPatchset(String review, String patchset) {
+ return documentExists('$documents/$review/patchsets/$patchset');
+ }
+
+ Commit _commit(Document document) {
+ document.fields['hash'] = taggedValue(document.name.split('/').last);
+ return Commit(document.name.split('/').last, document);
+ }
+
+ Future<Commit> getCommit(String hash) async {
+ final document =
+ await getDocument('$documents/commits/$hash', throwOnNotFound: false);
+ return document != null ? Commit(hash, document) : null;
+ }
+
+ Future<Commit> getCommitByIndex(int index) async {
+ final response =
+ await query(from: 'commits', where: fieldEquals('index', index));
+ return _commit(response.first.document);
+ }
+
+ Future<Commit> getLastCommit() async {
+ final lastCommit =
+ await query(from: 'commits', orderBy: orderBy('index', false));
+ return _commit(lastCommit.first.document);
+ }
+
+ Future<void> addCommit(String id, Map<String, dynamic> data) async {
+ try {
+ final document = Document.fromJson({'fields': taggedJsonMap(data)});
+ await firestore.projects.databases.documents
+ .createDocument(document, documents, 'commits', documentId: id);
+ log("Added commit $id -> ${data['index']}");
+ } on DetailedApiRequestError catch (e) {
+ if (e.status != 409) {
+ rethrow;
+ }
+ // The document exists, we can ignore this error as the data is already
+ // correct.
+ }
+ }
+
+ Future<void> updateConfiguration(String configuration, String builder) async {
+ final record = await getDocument('$documents/configurations/$configuration',
+ throwOnNotFound: false);
+ if (record == null) {
+ final newRecord = Document.fromJson({
+ 'fields': taggedJsonMap({'builder': builder})
+ });
+ await firestore.projects.databases.documents.createDocument(
+ newRecord, documents, 'configurations',
+ documentId: configuration);
+ log('Configuration document $configuration -> $builder created');
+ } else {
+ final originalBuilder = DataWrapper(record).getString('builder');
+ if (originalBuilder != builder) {
+ record.fields['builder'].stringValue = builder;
+ await updateFields(record, ['builder']);
+ log('Configuration document changed: $configuration -> $builder '
+ '(was $originalBuilder)');
+ }
+ }
+ }
+
+ /// Ensures that a build record for this build exists.
+ ///
+ /// Returns `true` if and only if there is no completed record
+ /// for this build.
+ Future<bool> updateBuildInfo(
+ String builder, int buildNumber, int index) async {
+ final record = await getDocument('$documents/builds/$builder:$index',
+ throwOnNotFound: false);
+ if (record == null) {
+ final newRecord = Document.fromJson({
+ 'fields': taggedJsonMap(
+ {'builder': builder, 'build_number': buildNumber, 'index': index})
+ });
+ await firestore.projects.databases.documents.createDocument(
+ newRecord, documents, 'builds',
+ documentId: '$builder:$index');
+ return true;
+ } else {
+ final data = DataWrapper(record);
+ final existingIndex = data.getInt('index');
+ if (existingIndex != index) {
+ throw ('Build $buildNumber of $builder had commit index '
+ '$existingIndex, should be $index.');
+ }
+ return data.getBool('completed') != true;
+ }
+ }
+
+ /// Ensures that a build record for this build exists.
+ ///
+ /// Returns `true` if and only if there is no completed record
+ /// for this build.
+ Future<bool> updateTryBuildInfo(String builder, int buildNumber,
+ String buildbucketID, int review, int patchset, bool success) async {
+ final name = '$builder:$review:$patchset';
+ final record = await getDocument('$documents/try_builds/$name',
+ throwOnNotFound: false);
+ if (record == null) {
+ final newRecord = Document.fromJson({
+ 'fields': taggedJsonMap({
+ 'builder': builder,
+ 'build_number': buildNumber,
+ if (buildbucketID != null) 'buildbucket_id': buildbucketID,
+ 'review': review,
+ 'patchset': patchset,
+ })
+ });
+ log('creating try-build record for $builder $buildNumber $review $patchset:'
+ ' $name');
+ await firestore.projects.databases.documents
+ .createDocument(newRecord, documents, 'try_builds', documentId: name);
+ return true;
+ } else {
+ final data = DataWrapper(record);
+ final existingBuildNumber = data.getInt('build_number');
+ if (existingBuildNumber > buildNumber) {
+ throw 'Received chunk from previous build $buildNumber'
+ ' after chunk from a later build ($existingBuildNumber)';
+ }
+ if (existingBuildNumber < buildNumber) {
+ record.fields = taggedMap({
+ 'builder': builder,
+ 'build_number': buildNumber,
+ if (buildbucketID != null) 'buildbucket_id': buildbucketID,
+ 'review': review,
+ 'patchset': patchset,
+ });
+ await _executeWrite([Write()..update = record]);
+ return true;
+ }
+ return data.getBool('completed') != true;
+ }
+ }
+
+ Future<String> findResult(
+ Map<String, dynamic> change, int startIndex, int endIndex) async {
+ final name = change['name'] as String;
+ final result = change['result'] as String;
+ final previousResult = change['previous_result'] as String;
+ final expected = change['expected'] as String;
+ final snapshot = await query(
+ from: 'results',
+ orderBy: orderBy('blamelist_end_index', false),
+ where: compositeFilter([
+ fieldEquals('name', name),
+ fieldEquals('result', result),
+ fieldEquals('previous_result', previousResult),
+ fieldEquals('expected', expected)
+ ]),
+ limit: 5);
+
+ bool blamelistIncludesChange(RunQueryResponse response) {
+ final document = response.document;
+ if (document == null) return false;
+ final groupStart =
+ int.parse(document.fields['blamelist_start_index'].integerValue);
+ final groupEnd =
+ int.parse(document.fields['blamelist_end_index'].integerValue);
+ return startIndex <= groupEnd && endIndex >= groupStart;
+ }
+
+ return snapshot
+ .firstWhere(blamelistIncludesChange, orElse: () => null)
+ ?.document
+ ?.name;
+ }
+
+ Future<void> storeResult(Map<String, dynamic> result) async {
+ final document = Document.fromJson({'fields': taggedJsonMap(result)});
+ final createdDocument = await firestore.projects.databases.documents
+ .createDocument(document, documents, 'results');
+ log('created document ${createdDocument.name}');
+ }
+
+ Future<bool> updateResult(
+ String result, String configuration, int startIndex, int endIndex,
+ {bool failure}) async {
+ var approved;
+ await retryCommit(() async {
+ final document = await getDocument(result);
+ final data = DataWrapper(document);
+ // Allow missing 'approved' field during transition period.
+ approved = data.getBool('approved') ?? false;
+ // Add the new configuration and narrow the blamelist.
+ final newStart = max(startIndex, data.getInt('blamelist_start_index'));
+ final newEnd = min(endIndex, data.getInt('blamelist_end_index'));
+ // TODO(karlklose): check for pinned, and remove the pin if the new range
+ // doesn't include it?
+ final updates = [
+ 'blamelist_start_index',
+ 'blamelist_end_index',
+ if (failure) 'active'
+ ];
+ document.fields['blamelist_start_index'] = taggedValue(newStart);
+ document.fields['blamelist_end_index'] = taggedValue(newEnd);
+ if (failure) {
+ document.fields['active'] = taggedValue(true);
+ }
+ final addConfiguration = ArrayValue()
+ ..values = [taggedValue(configuration)];
+ final write = Write()
+ ..currentDocument = (Precondition()..updateTime = document.updateTime)
+ ..update = document
+ ..updateMask = (DocumentMask()..fieldPaths = updates)
+ ..updateTransforms = [
+ FieldTransform()
+ ..fieldPath = 'configurations'
+ ..appendMissingElements = addConfiguration,
+ if (failure)
+ FieldTransform()
+ ..fieldPath = 'active_configurations'
+ ..appendMissingElements = addConfiguration
+ ];
+
+ return write;
+ });
+ return approved;
+ }
+
+ Future retryCommit(Future<Write> Function() request) async {
+ while (true) {
+ final write = await request();
+ try {
+ // Use commit instead of write to check for the precondition on the
+ // document
+ final request = CommitRequest()..writes = [write];
+ documentsWritten++;
+ await firestore.projects.databases.documents.commit(request, database);
+ return;
+ } catch (e) {
+ log('Error while writing data: $e, retrying...');
+ sleep(Duration(milliseconds: 100));
+ }
+ }
+ }
+
+ /// Returns all results which are either pinned to or have a range that is
+ /// this single index. // TODO: rename this function
+ Future<List<Map<String, Value>>> findRevertedChanges(int index) async {
+ final pinnedResults =
+ await query(from: 'results', where: fieldEquals('pinned_index', index));
+ final results =
+ pinnedResults.map((response) => response.document.fields).toList();
+ final unpinnedResults = await query(
+ from: 'results', where: fieldEquals('blamelist_end_index', index));
+ for (final unpinnedResult in unpinnedResults) {
+ final data = DataWrapper(unpinnedResult.document);
+ if (data.getInt('blamelist_start_index') == index &&
+ data.isNull('pinned_index')) {
+ results.add(unpinnedResult.document.fields);
+ }
+ }
+ return results;
+ }
+
+ Future<bool> storeTryChange(
+ Map<String, dynamic> change, int review, int patchset) async {
+ final name = change['name'] as String;
+ final result = change['result'] as String;
+ final expected = change['expected'] as String;
+ final previousResult = change['previous_result'] as String;
+ final configuration = change['configuration'] as String;
+
+ // Find an existing result record for this test on this patchset.
+ final responses = await query(
+ from: 'try_results',
+ where: compositeFilter([
+ fieldEquals('review', review),
+ fieldEquals('patchset', patchset),
+ fieldEquals('name', name),
+ fieldEquals('result', result),
+ fieldEquals('previous_result', previousResult),
+ fieldEquals('expected', expected)
+ ]),
+ limit: 1);
+ // TODO(karlklose): We could run only this query, and then see if the
+ // patchset is equal or not. We don't need the separate
+ // query with equal patchset.
+ // The test for previous.isNotEmpty below can be replaced
+ // with responses.patchset != patchset. We need to hit
+ // the createDocument both if there was a previous response,
+ // or there is no response at all.
+ if (responses.isEmpty) {
+ // Is the previous result for this test on this review approved?
+ final previous = await query(
+ from: 'try_results',
+ where: compositeFilter([
+ fieldEquals('review', review),
+ fieldEquals('name', name),
+ fieldEquals('result', result),
+ fieldEquals('previous_result', previousResult),
+ fieldEquals('expected', expected),
+ ]),
+ orderBy: orderBy('patchset', false),
+ limit: 1);
+ final approved = previous.isNotEmpty &&
+ DataWrapper(previous.first.document).getBool('approved') == true;
+
+ final document = Document.fromJson({
+ 'fields': taggedJsonMap({
+ 'name': name,
+ 'result': result,
+ 'previous_result': previousResult,
+ 'expected': expected,
+ 'review': review,
+ 'patchset': patchset,
+ 'configurations': <String>[configuration],
+ 'approved': approved
+ })
+ });
+ await firestore.projects.databases.documents.createDocument(
+ document,
+ 'projects/dart-ci-staging/databases/(default)/documents',
+ 'try_results',
+ mask_fieldPaths: [
+ 'name',
+ 'result',
+ 'previous_result',
+ 'expected',
+ 'review',
+ 'patchset',
+ 'configurations',
+ 'approved'
+ ]);
+ return approved;
+ } else {
+ final document = responses.first.document;
+ // Update the TryResult for this test, adding this configuration.
+ final values = ArrayValue()..values = [taggedValue(configuration)];
+ final addConfiguration = FieldTransform()
+ ..fieldPath = 'configurations'
+ ..appendMissingElements = values;
+ await _executeWrite([
+ Write()
+ ..update = document
+ ..updateTransforms = [addConfiguration]
+ ]);
+ return DataWrapper(document).getBool('approved') == true;
+ }
+ }
+
+ Future<void> approveResult(Document document) async {
+ document.fields['approved'] = taggedValue(true);
+ await _executeWrite([
+ Write()
+ ..update = document
+ ..updateMask = (DocumentMask()..fieldPaths = ['approved'])
+ ]);
+ }
+
+ /// Removes [configuration] from the active configurations and marks the
+ /// active result inactive when we remove the last active config.
+ Future<void> updateActiveResult(
+ Document activeResult, String configuration) async {
+ final data = DataWrapper(activeResult);
+ final configurations = data.getList('active_configurations');
+ assert(configurations.contains(configuration));
+ if (configurations.length > 1) {
+ await removeArrayEntry(
+ activeResult, 'active_configurations', taggedValue(configuration));
+ activeResult = await getDocument(activeResult.name);
+ }
+ if (DataWrapper(activeResult).getList('active_configurations').isEmpty) {
+ activeResult.fields.remove('active_configurations');
+ activeResult.fields.remove('active');
+ final write = Write()
+ ..update = activeResult
+ ..updateMask =
+ (DocumentMask()..fieldPaths = ['active', 'active_configurations']);
+ await _executeWrite([write]);
+ }
+ }
+
+ Future<void> removeArrayEntry(
+ Document document, String fieldName, Value entry) async {
+ await _executeWrite([
+ Write()
+ ..transform = (DocumentTransform()
+ ..fieldTransforms = [
+ FieldTransform()
+ ..fieldPath = fieldName
+ ..removeAllFromArray = (ArrayValue()..values = [entry])
+ ])
+ ]);
+ }
+
+ Future<List<Document>> findActiveResults(
+ String name, String configuration) async {
+ final results = await query(
+ from: 'results',
+ where: compositeFilter([
+ arrayContains('active_configurations', configuration),
+ fieldEquals('active', true),
+ fieldEquals('name', name)
+ ]));
+ if (results.length > 1) {
+ log([
+ 'Multiple active results for the same configuration and test',
+ ...results
+ ].join('\n'));
+ }
+ return results.map((RunQueryResponse result) => result.document).toList();
+ }
+
+ Future storeReview(String review, Map<String, dynamic> data) {
+ final fields = {'fields': taggedJsonMap(data)};
+ final document = Document.fromJson(fields);
+ documentsWritten++;
+ return firestore.projects.databases.documents
+ .createDocument(document, documents, 'reviews', documentId: '$review');
+ }
+
+ Future<void> deleteDocument(String name) async {
+ return _executeWrite([Write()..delete = name]);
+ }
+
+ Future<bool> documentExists(String name) async {
+ return (await getDocument(name, throwOnNotFound: false) != null);
+ }
+
+ Future _executeWrite(List<Write> writes) async {
+ const debug = false;
+ final request = BatchWriteRequest()..writes = writes;
+ if (debug) {
+ log('WriteRequest: ${request.toJson()}');
+ }
+ documentsWritten++;
+ return firestore.projects.databases.documents.batchWrite(request, database);
+ }
+
+ Future<void> updateFields(Document document, List<String> fields) async {
+ await _executeWrite([
+ Write()
+ ..update = document
+ ..updateMask = (DocumentMask()..fieldPaths = fields)
+ ]);
+ }
+
+ Future<void> storePatchset(String review, int patchset, String kind,
+ String description, int patchsetGroup, int number) async {
+ final document = Document.fromJson({
+ 'fields': taggedJsonMap({
+ 'kind': kind,
+ 'description': description,
+ 'patchset_group': patchsetGroup,
+ 'number': number
+ })
+ });
+ await firestore.projects.databases.documents.createDocument(
+ document, '$documents/reviews/$review', 'patchsets',
+ documentId: '$patchset');
+ }
+
+ /// Returns true if a review record in the database has a landed_index field,
+ /// or if there is no record for the review in the database. Reviews with no
+ /// test failures have no record, and don't need to be linked when landing.
+ Future<bool> reviewIsLanded(int review) async {
+ final document =
+ await getDocument('$documents/reviews/$review', throwOnNotFound: false);
+ if (document == null) {
+ return true;
+ }
+ return document.fields.containsKey('landed_index');
+ }
+
+ Future<void> linkReviewToCommit(int review, int index) async {
+ final document = await getDocument('$documents/reviews/$review');
+ document.fields['landed_index'] = taggedValue(index);
+ await updateFields(document, ['landed_index']);
+ }
+
+ Future<void> linkCommentsToCommit(int review, int index) async {
+ final comments =
+ await query(from: 'comments', where: fieldEquals('review', review));
+ if (comments.isEmpty) return;
+ final writes = <Write>[];
+ for (final comment in comments) {
+ final document = comment.document;
+ document.fields['blamelist_start_index'] = taggedValue(index);
+ document.fields['blamelist_end_index'] = taggedValue(index);
+ writes.add(Write()
+ ..update = document
+ ..updateMask = (DocumentMask()
+ ..fieldPaths = ['blamelist_start_index', 'blamelist_end_index']));
+ }
+ await _executeWrite(writes);
+ }
+
+ Future<List<Map<String, Value>>> tryApprovals(int review) async {
+ final patchsets = await query(
+ from: 'patchsets',
+ parent: 'reviews/$review',
+ orderBy: orderBy('number', false),
+ limit: 1);
+ if (patchsets.isEmpty) {
+ return [];
+ }
+ final lastPatchsetGroup =
+ DataWrapper(patchsets.first.document).getInt('patchset_group');
+ final approvals = await query(
+ from: 'try_results',
+ where: compositeFilter([
+ fieldEquals('approved', true),
+ fieldEquals('review', review),
+ fieldGreaterThanOrEqual('patchset', lastPatchsetGroup)
+ ]));
+
+ return approvals.map((response) => response.document.fields).toList();
+ }
+
+ Future<List<Map<String, Value>>> tryResults(
+ int review, String configuration) async {
+ final patchsets = await query(
+ from: 'patchsets',
+ parent: 'reviews/$review',
+ orderBy: orderBy('number', false),
+ limit: 1);
+ if (patchsets.isEmpty) {
+ return [];
+ }
+ final lastPatchsetGroup =
+ DataWrapper(patchsets.first.document).getInt('patchset_group');
+ final approvals = await query(
+ from: 'try_results',
+ where: compositeFilter([
+ fieldEquals('review', review),
+ arrayContains('configurations', configuration),
+ fieldGreaterThanOrEqual('patchset', lastPatchsetGroup)
+ ]));
+ return approvals.map((r) => r.document.fields).toList();
+ }
+
+ Future<void> completeBuilderRecord(
+ String builder, int index, bool success) async {
+ final path = '$documents/builds/$builder:$index';
+ final document = await getDocument(path);
+ await _completeBuilderRecord(document, success);
+ }
+
+ Future<void> completeTryBuilderRecord(
+ String builder, int review, int patchset, bool success) async {
+ final path = '$documents/try_builds/$builder:$review:$patchset';
+ final document = await getDocument(path);
+ await _completeBuilderRecord(document, success);
+ }
+
+ Future<void> _completeBuilderRecord(Document document, bool success) async {
+ await retryCommit(() async {
+ final data = DataWrapper(document);
+ // TODO: Legacy support, remove if not needed anymore.
+ document.fields['processed_chunks'] = taggedValue(1);
+ document.fields['num_chunks'] = taggedValue(1);
+ document.fields['success'] =
+ taggedValue((data.getBool('success') ?? true) && success);
+ document.fields['completed'] = taggedValue(true);
+
+ final write = Write()
+ ..update = document
+ ..updateMask = (DocumentMask()
+ ..fieldPaths = [
+ 'processed_chunks',
+ 'num_chunks',
+ 'success',
+ 'completed'
+ ])
+ ..currentDocument = (Precondition()..updateTime = document.updateTime);
+ return write;
+ });
+ }
+}
diff --git a/builder/lib/src/gerrit_change.dart b/builder/lib/src/gerrit_change.dart
new file mode 100644
index 0000000..a9ba26d
--- /dev/null
+++ b/builder/lib/src/gerrit_change.dart
@@ -0,0 +1,72 @@
+// 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.
+
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+import 'firestore.dart';
+
+class GerritInfo {
+ static const gerritUrl = 'https://dart-review.googlesource.com/changes';
+ static const gerritQuery =
+ 'o=ALL_REVISIONS&o=DETAILED_ACCOUNTS&o=CURRENT_COMMIT';
+ static const trivialKinds = {
+ 'TRIVIAL_REBASE',
+ 'NO_CHANGE',
+ 'NO_CODE_CHANGE',
+ };
+ static const prefix = ")]}'\n";
+
+ http.BaseClient httpClient;
+ FirestoreService firestore;
+ String review;
+ String patchset;
+
+ GerritInfo(int review, int patchset, this.firestore, this.httpClient) {
+ this.review = review.toString();
+ this.patchset = patchset.toString();
+ }
+
+ /// Fetches the owner, changeId, message, and date of a Gerrit change and
+ /// stores them in the databases.
+ Future<void> update() async {
+ if (await firestore.hasPatchset(review, patchset)) return;
+ // Get the Gerrit change's commit from the Gerrit API.
+ final url = '$gerritUrl/$review?$gerritQuery';
+ final response = await httpClient.get(url);
+ final protectedJson = response.body;
+ if (!protectedJson.startsWith(prefix)) {
+ throw Exception('Gerrit response missing prefix $prefix: $protectedJson');
+ }
+ final reviewInfo = jsonDecode(protectedJson.substring(prefix.length))
+ as Map<String, dynamic>;
+ final reverted = revert(reviewInfo);
+ await firestore.storeReview(review, {
+ 'subject': taggedValue(reviewInfo['subject']),
+ if (reverted != null) 'revert_of': taggedValue(reverted)
+ });
+
+ // Add the patchset information to the patchsets subcollection.
+ final revisions = reviewInfo['revisions'].values.toList()
+ ..sort((a, b) => (a['_number'] as int).compareTo(b['_number']));
+ int patchsetGroupFirst;
+ for (Map<String, dynamic> revision in revisions) {
+ int number = revision['_number'];
+ if (!trivialKinds.contains(revision['kind'])) {
+ patchsetGroupFirst = number;
+ }
+ await firestore.storePatchset(review, number, revision['kind'],
+ revision['description'], patchsetGroupFirst, number);
+ }
+ }
+
+ static String revert(Map<String, dynamic> reviewInfo) {
+ final current = reviewInfo['current_revision'];
+ final commit = reviewInfo['revisions'][current]['commit'];
+ final regExp =
+ RegExp('^This reverts commit ([\\da-f]+)\\.\$', multiLine: true);
+ return regExp.firstMatch(commit['message'])?.group(1);
+ }
+}
diff --git a/builder/lib/src/result.dart b/builder/lib/src/result.dart
new file mode 100644
index 0000000..b1271e9
--- /dev/null
+++ b/builder/lib/src/result.dart
@@ -0,0 +1,67 @@
+// Copyright (c) 2020, 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.
+
+// Field names and helper functions for result documents and
+// commit documents from Firestore.
+
+// Field names of Result document fields
+
+import 'package:googleapis/firestore/v1.dart' show Value;
+
+const fName = 'name';
+const fResult = 'result';
+const fPreviousResult = 'previous_result';
+const fExpected = 'expected';
+const fChanged = 'changed';
+const fMatches = 'matches';
+const fFlaky = 'flaky';
+const fPreviousFlaky = 'previous_flaky';
+const fPinnedIndex = 'pinned_index';
+const fBlamelistStartIndex = 'blamelist_start_index';
+const fBlamelistEndIndex = 'blamelist_end_index';
+const fApproved = 'approved';
+const fActive = 'active';
+const fConfigurations = 'configurations';
+const fActiveConfigurations = 'active_configurations';
+
+bool isChangedResult(Map<String, dynamic> change) =>
+ change[fChanged] && (!change[fFlaky] || !change[fPreviousFlaky]);
+
+/// Whether the change will be marked as an active failure.
+/// New flaky tests will not be marked active, so they will appear in the
+/// results feed "all", but not turn the builder red
+bool isFailure(Map<String, dynamic> change) =>
+ !change[fMatches] && change[fResult] != 'flaky';
+
+void transformChange(Map<String, dynamic> change) {
+ change[fPreviousResult] ??= 'new test';
+ if (change[fPreviousFlaky]) {
+ change[fPreviousResult] = 'flaky';
+ }
+ if (change[fFlaky]) {
+ change[fResult] = 'flaky';
+ change[fMatches] = false;
+ }
+}
+
+String fromStringOrValue(dynamic value) {
+ return value is Value ? value.stringValue : value;
+}
+
+String testResult(Map<String, dynamic> change) => [
+ fromStringOrValue(change[fName]),
+ fromStringOrValue(change[fResult]),
+ fromStringOrValue(change[fPreviousResult]),
+ fromStringOrValue(change[fExpected])
+ ].join(' ');
+
+// Field names of commit document fields
+const fHash = 'hash';
+const fIndex = 'index';
+const fAuthor = 'author';
+const fCreated = 'created';
+const fTitle = 'title';
+const fReview = 'review';
+const fRevertOf = 'revert_of';
+const fRelandOf = 'reland_of';
diff --git a/builder/lib/src/reverted_changes.dart b/builder/lib/src/reverted_changes.dart
new file mode 100644
index 0000000..d7bf314
--- /dev/null
+++ b/builder/lib/src/reverted_changes.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2020, 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 'package:collection/collection.dart';
+import 'package:googleapis/firestore/v1.dart';
+
+import 'firestore.dart';
+import 'result.dart';
+
+Future<RevertedChanges> getRevertedChanges(
+ String reverted, int revertIndex, FirestoreService firestore) async {
+ final revertedCommit = await firestore.getCommit(reverted);
+ if (revertedCommit == null) {
+ throw 'Cannot find commit for reverted commit hash $reverted';
+ }
+ final index = revertedCommit.index;
+ final changes = await firestore.findRevertedChanges(index);
+ return RevertedChanges(index, revertIndex, changes,
+ groupBy(changes, (change) => getValue(change[fName])));
+}
+
+class RevertedChanges {
+ final int index;
+ final int revertIndex;
+ final List<Map<String, Value>> changes;
+ final Map<String, List<Map<String, Value>>> changesForTest;
+
+ RevertedChanges(
+ this.index, this.revertIndex, this.changes, this.changesForTest);
+
+ bool approveRevert(Map<String, dynamic> revert) {
+ final reverted = changesForTest[revert[fName]];
+ return isFailure(revert) &&
+ reverted != null &&
+ reverted.any(
+ (change) => revert[fResult] == getValue(change[fPreviousResult]));
+ }
+}
diff --git a/builder/lib/src/tryjob.dart b/builder/lib/src/tryjob.dart
new file mode 100644
index 0000000..f9907a7
--- /dev/null
+++ b/builder/lib/src/tryjob.dart
@@ -0,0 +1,141 @@
+// 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.
+
+import 'package:collection/collection.dart';
+import 'package:googleapis/firestore/v1.dart';
+import 'package:http/http.dart' as http show BaseClient;
+import 'package:pool/pool.dart';
+
+import 'commits_cache.dart';
+import 'firestore.dart';
+import 'gerrit_change.dart';
+import 'result.dart';
+
+class Tryjob {
+ static final changeRefRegExp = RegExp(r'refs/changes/(\d*)/(\d*)');
+ final http.BaseClient httpClient;
+ final FirestoreService firestore;
+ final CommitsCache commits;
+ String builderName;
+ String baseRevision;
+ String baseResultsHash;
+ int buildNumber;
+ int review;
+ int patchset;
+ bool success = true;
+ List<Map<String, Value>> landedResults;
+ Map<String, Map<String, Value>> lastLandedResultByName = {};
+ final String buildbucketID;
+ int countChanges = 0;
+ int countUnapproved = 0;
+ int countNewFlakes = 0;
+
+ Tryjob(String changeRef, this.buildbucketID, this.baseRevision, this.commits,
+ this.firestore, this.httpClient) {
+ final match = changeRefRegExp.matchAsPrefix(changeRef);
+ review = int.parse(match[1]);
+ patchset = int.parse(match[2]);
+ }
+
+ void log(String string) => firestore.log(string);
+
+ Future<void> update() async {
+ await GerritInfo(review, patchset, firestore, httpClient).update();
+ }
+
+ bool isNotLandedResult(Map<String, dynamic> change) =>
+ !lastLandedResultByName.containsKey(change[fName]) ||
+ change[fResult] != lastLandedResultByName[change[fName]][fResult];
+
+ Future<void> process(List<Map<String, dynamic>> results) async {
+ await update();
+ builderName = results.first['builder_name'];
+ buildNumber = int.parse(results.first['build_number']);
+
+ if (!await firestore.updateTryBuildInfo(
+ builderName, buildNumber, buildbucketID, review, patchset, success)) {
+ // This build's results have already been recorded.
+ log('build up-to-date, exiting');
+ return;
+ }
+
+ baseResultsHash = results.first['previous_commit_hash'];
+ final resultsByConfiguration = groupBy<Map<String, dynamic>, String>(
+ results.where(isChangedResult), (result) => result['configuration']);
+
+ for (final configuration in resultsByConfiguration.keys) {
+ log('Fetching landed results for configuration $configuration');
+ if (baseRevision != null && baseResultsHash != null) {
+ landedResults = await fetchLandedResults(configuration);
+ // Map will contain the last result with each name.
+ lastLandedResultByName = {
+ for (final result in landedResults)
+ getValue(result[fName]) as String: result
+ };
+ }
+ log('Processing results');
+ await Pool(30)
+ .forEach(
+ resultsByConfiguration[configuration].where(isNotLandedResult),
+ storeChange)
+ .drain();
+ }
+
+ log('complete builder record');
+ await firestore.completeTryBuilderRecord(
+ builderName, review, patchset, success);
+
+ final report = [
+ 'Processed ${results.length} results from $builderName build $buildNumber',
+ 'Tryjob on CL $review patchset $patchset',
+ if (countChanges > 0) 'Stored $countChanges changes',
+ if (!success) 'Found unapproved new failures',
+ if (countUnapproved > 0) '$countUnapproved unapproved tests found',
+ if (countNewFlakes > 0) '$countNewFlakes new flaky tests found',
+ '${firestore.documentsFetched} documents fetched',
+ '${firestore.documentsWritten} documents written',
+ ];
+ log(report.join('\n'));
+ }
+
+ Future<void> storeChange(Map<String, dynamic> change) async {
+ countChanges++;
+ transformChange(change);
+ final approved = await firestore.storeTryChange(change, review, patchset);
+ if (!approved && isFailure(change)) {
+ countUnapproved++;
+ success = false;
+ }
+ if (change[fFlaky] && !change[fPreviousFlaky]) {
+ if (++countNewFlakes >= 10) {
+ success = false;
+ }
+ }
+ }
+
+ Future<List<Map<String, Value>>> fetchLandedResults(
+ String configuration) async {
+ final resultsBase = await commits.getCommit(baseResultsHash);
+ final rebaseBase = await commits.getCommit(baseRevision);
+ final results = <Map<String, Value>>[];
+ if (resultsBase.index > rebaseBase.index) {
+ print('Try build is rebased on $baseRevision, which is before '
+ 'the commit $baseResultsHash with CI comparison results');
+ return results;
+ }
+ final reviews = <int>[];
+ for (var index = resultsBase.index + 1;
+ index <= rebaseBase.index;
+ ++index) {
+ final commit = await commits.getCommitByIndex(index);
+ if (commit.review != null) {
+ reviews.add(commit.review);
+ }
+ }
+ for (final landedReview in reviews) {
+ results.addAll(await firestore.tryResults(landedReview, configuration));
+ }
+ return results;
+ }
+}
diff --git a/builder/pubspec.lock b/builder/pubspec.lock
new file mode 100644
index 0000000..26f1a3c
--- /dev/null
+++ b/builder/pubspec.lock
@@ -0,0 +1,586 @@
+# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+ _discoveryapis_commons:
+ dependency: transitive
+ description:
+ name: _discoveryapis_commons
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.1"
+ analyzer:
+ dependency: transitive
+ description:
+ name: analyzer
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.38.5"
+ args:
+ dependency: "direct main"
+ description:
+ name: args
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.6.0"
+ async:
+ dependency: transitive
+ description:
+ name: async
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.4.2"
+ bazel_worker:
+ dependency: transitive
+ description:
+ name: bazel_worker
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.1.25"
+ boolean_selector:
+ dependency: transitive
+ description:
+ name: boolean_selector
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.0.0"
+ build:
+ dependency: transitive
+ description:
+ name: build
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.2"
+ build_config:
+ dependency: transitive
+ description:
+ name: build_config
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.4.2"
+ build_daemon:
+ dependency: transitive
+ description:
+ name: build_daemon
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.1.10"
+ build_modules:
+ dependency: transitive
+ description:
+ name: build_modules
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.9.0"
+ build_node_compilers:
+ dependency: "direct dev"
+ description:
+ name: build_node_compilers
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.4"
+ build_resolvers:
+ dependency: transitive
+ description:
+ name: build_resolvers
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.1"
+ build_runner:
+ dependency: "direct dev"
+ description:
+ name: build_runner
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.9.0"
+ build_runner_core:
+ dependency: transitive
+ description:
+ name: build_runner_core
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "5.1.0"
+ built_collection:
+ dependency: transitive
+ description:
+ name: built_collection
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "4.3.2"
+ built_value:
+ dependency: transitive
+ description:
+ name: built_value
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "7.1.0"
+ charcode:
+ dependency: transitive
+ description:
+ name: charcode
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.1.3"
+ checked_yaml:
+ dependency: transitive
+ description:
+ name: checked_yaml
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.0.4"
+ code_builder:
+ dependency: transitive
+ description:
+ name: code_builder
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "3.7.0"
+ collection:
+ dependency: transitive
+ description:
+ name: collection
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.14.13"
+ convert:
+ dependency: transitive
+ description:
+ name: convert
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.1.1"
+ coverage:
+ dependency: transitive
+ description:
+ name: coverage
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.14.2"
+ crypto:
+ dependency: transitive
+ description:
+ name: crypto
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.1.5"
+ csslib:
+ dependency: transitive
+ description:
+ name: csslib
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.16.2"
+ dart_style:
+ dependency: transitive
+ description:
+ name: dart_style
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.3.3"
+ file:
+ dependency: transitive
+ description:
+ name: file
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "5.2.1"
+ fixnum:
+ dependency: transitive
+ description:
+ name: fixnum
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.10.11"
+ front_end:
+ dependency: transitive
+ description:
+ name: front_end
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.1.27"
+ glob:
+ dependency: transitive
+ description:
+ name: glob
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.0"
+ googleapis:
+ dependency: "direct main"
+ description:
+ name: googleapis
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.0.0"
+ googleapis_auth:
+ dependency: "direct main"
+ description:
+ name: googleapis_auth
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.12+1"
+ graphs:
+ dependency: transitive
+ description:
+ name: graphs
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.0"
+ html:
+ dependency: transitive
+ description:
+ name: html
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.14.0+4"
+ http:
+ dependency: "direct main"
+ description:
+ name: http
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.12.2"
+ http_multi_server:
+ dependency: transitive
+ description:
+ name: http_multi_server
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.2.0"
+ http_parser:
+ dependency: transitive
+ description:
+ name: http_parser
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "3.1.4"
+ intl:
+ dependency: transitive
+ description:
+ name: intl
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.16.1"
+ io:
+ dependency: transitive
+ description:
+ name: io
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.3.5"
+ js:
+ dependency: transitive
+ description:
+ name: js
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.6.3"
+ json_annotation:
+ dependency: transitive
+ description:
+ name: json_annotation
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "3.1.1"
+ kernel:
+ dependency: transitive
+ description:
+ name: kernel
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.3.27"
+ logging:
+ dependency: transitive
+ description:
+ name: logging
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.11.4"
+ matcher:
+ dependency: transitive
+ description:
+ name: matcher
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.12.6"
+ meta:
+ dependency: transitive
+ description:
+ name: meta
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.4"
+ mime:
+ dependency: transitive
+ description:
+ name: mime
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.9.7"
+ mockito:
+ dependency: "direct dev"
+ description:
+ name: mockito
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "4.1.1+1"
+ multi_server_socket:
+ dependency: transitive
+ description:
+ name: multi_server_socket
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.0.2"
+ node_interop:
+ dependency: transitive
+ description:
+ name: node_interop
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.1"
+ node_io:
+ dependency: transitive
+ description:
+ name: node_io
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.0"
+ node_preamble:
+ dependency: transitive
+ description:
+ name: node_preamble
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.4.13"
+ package_config:
+ dependency: transitive
+ description:
+ name: package_config
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.9.3"
+ package_resolver:
+ dependency: transitive
+ description:
+ name: package_resolver
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.0.10"
+ path:
+ dependency: transitive
+ description:
+ name: path
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.7.0"
+ pedantic:
+ dependency: "direct dev"
+ description:
+ name: pedantic
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.11.0"
+ pool:
+ dependency: "direct main"
+ description:
+ name: pool
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.4.0"
+ protobuf:
+ dependency: transitive
+ description:
+ name: protobuf
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.1.3"
+ pub_semver:
+ dependency: transitive
+ description:
+ name: pub_semver
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.4.4"
+ pubspec_parse:
+ dependency: transitive
+ description:
+ name: pubspec_parse
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.1.8"
+ quiver:
+ dependency: transitive
+ description:
+ name: quiver
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.1.5"
+ retry:
+ dependency: "direct main"
+ description:
+ name: retry
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "3.1.0"
+ scratch_space:
+ dependency: transitive
+ description:
+ name: scratch_space
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.0.4+3"
+ shelf:
+ dependency: transitive
+ description:
+ name: shelf
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.7.9"
+ shelf_packages_handler:
+ dependency: transitive
+ description:
+ name: shelf_packages_handler
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.0.1"
+ shelf_static:
+ dependency: transitive
+ description:
+ name: shelf_static
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.9+2"
+ shelf_web_socket:
+ dependency: transitive
+ description:
+ name: shelf_web_socket
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.4+1"
+ source_map_stack_trace:
+ dependency: transitive
+ description:
+ name: source_map_stack_trace
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.0.0"
+ source_maps:
+ dependency: transitive
+ description:
+ name: source_maps
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.10.9"
+ source_span:
+ dependency: transitive
+ description:
+ name: source_span
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.7.0"
+ stack_trace:
+ dependency: transitive
+ description:
+ name: stack_trace
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.9.6"
+ stream_channel:
+ dependency: transitive
+ description:
+ name: stream_channel
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.0.0"
+ stream_transform:
+ dependency: transitive
+ description:
+ name: stream_transform
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.0"
+ string_scanner:
+ dependency: transitive
+ description:
+ name: string_scanner
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.0.5"
+ term_glyph:
+ dependency: transitive
+ description:
+ name: term_glyph
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.1.0"
+ test:
+ dependency: "direct dev"
+ description:
+ name: test
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.14.7"
+ test_api:
+ dependency: transitive
+ description:
+ name: test_api
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.2.16"
+ test_core:
+ dependency: transitive
+ description:
+ name: test_core
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.3.7"
+ timing:
+ dependency: transitive
+ description:
+ name: timing
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.1.1+3"
+ typed_data:
+ dependency: transitive
+ description:
+ name: typed_data
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.0"
+ vm_service:
+ dependency: transitive
+ description:
+ name: vm_service
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "4.2.0"
+ watcher:
+ dependency: transitive
+ description:
+ name: watcher
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.9.7+15"
+ web_socket_channel:
+ dependency: transitive
+ description:
+ name: web_socket_channel
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "1.2.0"
+ webkit_inspection_protocol:
+ dependency: transitive
+ description:
+ name: webkit_inspection_protocol
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "0.7.5"
+ yaml:
+ dependency: transitive
+ description:
+ name: yaml
+ url: "https://pub.dartlang.org"
+ source: hosted
+ version: "2.2.1"
+sdks:
+ dart: ">=2.12.0-0 <3.0.0"
diff --git a/builder/pubspec.yaml b/builder/pubspec.yaml
new file mode 100644
index 0000000..eddd48c
--- /dev/null
+++ b/builder/pubspec.yaml
@@ -0,0 +1,22 @@
+name: builder
+description: Scripts run on Dart CQ/CI builders
+author: "Dart Team <misc@dartlang.org>"
+version: 0.1.0
+
+environment:
+ sdk: '^2.10.0'
+
+dependencies:
+ args: 1.6.0
+ googleapis_auth: 0.2.12+1
+ googleapis: 1.0.0
+ http: 0.12.2
+ pool: 1.4.0
+ retry: 3.1.0
+
+dev_dependencies:
+ pedantic: ^1.10.0
+ build_runner: ^1.7.1
+ build_node_compilers: ^0.2.3
+ mockito: ^4.1.0
+ test: ^1.9.4
diff --git a/builder/test/fakes.dart b/builder/test/fakes.dart
new file mode 100644
index 0000000..c81e8c6
--- /dev/null
+++ b/builder/test/fakes.dart
@@ -0,0 +1,208 @@
+// Copyright (c) 2020, 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:math';
+
+import 'package:googleapis/firestore/v1.dart';
+import 'package:mockito/mockito.dart';
+import 'package:http/http.dart';
+
+import 'package:builder/src/builder.dart';
+import 'package:builder/src/commits_cache.dart';
+import 'package:builder/src/firestore.dart';
+import 'package:builder/src/result.dart';
+import 'test_data.dart';
+
+class BuilderTest {
+ final client = HttpClientMock();
+ final firestore = FirestoreServiceFake();
+ CommitsCache commitsCache;
+ Build builder;
+ String commitHash;
+ Map<String, dynamic> firstChange;
+
+ BuilderTest(this.commitHash, this.firstChange) {
+ commitsCache = CommitsCache(firestore, client);
+ builder = Build(commitHash, firstChange, commitsCache, firestore);
+ }
+
+ Future<void> update() async {
+ await storeBuildCommitsInfo();
+ }
+
+ Future<void> storeBuildCommitsInfo() async {
+ await builder.storeBuildCommitsInfo();
+ // Test expectations
+ }
+
+ Future<void> storeChange(Map<String, dynamic> change) async {
+ return builder.storeChange(change);
+ }
+}
+
+class FirestoreServiceFake extends Fake implements FirestoreService {
+ Map<String, Map<String, dynamic>> commits = Map.from(fakeFirestoreCommits);
+ Map<String, Map<String, dynamic>> results = Map.from(fakeFirestoreResults);
+ List<Map<String, dynamic>> fakeTryResults =
+ List.from(fakeFirestoreTryResults);
+ int addedResultIdCounter = 1;
+
+ @override
+ Future<bool> isStaging() async => false;
+
+ @override
+ Future<Commit> getCommit(String hash) async {
+ final commit = commits[hash];
+ if (commit == null) {
+ return null;
+ }
+ return Commit.fromJson(hash, commits[hash]);
+ }
+
+ @override
+ Future<Commit> getCommitByIndex(int index) {
+ for (final entry in commits.entries) {
+ if (entry.value[fIndex] == index) {
+ return Future.value(Commit.fromJson(entry.key, entry.value));
+ }
+ }
+ throw 'No commit found with index $index';
+ }
+
+ @override
+ Future<Commit> getLastCommit() => getCommitByIndex(
+ commits.values.map<int>((commit) => commit[fIndex]).reduce(max));
+
+ @override
+ Future<void> addCommit(String id, Map<String, dynamic> data) async {
+ commits[id] = data..[fHash] = id;
+ }
+
+ @override
+ Future<String> findResult(
+ Map<String, dynamic> change, int startIndex, int endIndex) {
+ var resultId;
+ var resultEndIndex;
+ for (final entry in results.entries) {
+ final result = entry.value;
+ if (result[fName] == change[fName] &&
+ result[fResult] == change[fResult] &&
+ result[fExpected] == change[fExpected] &&
+ result[fPreviousResult] == change[fPreviousResult] &&
+ result[fBlamelistEndIndex] >= startIndex &&
+ result[fBlamelistStartIndex] <= endIndex) {
+ if (resultEndIndex == null ||
+ resultEndIndex < result[fBlamelistEndIndex]) {
+ resultId = entry.key;
+ resultEndIndex = result[fBlamelistEndIndex];
+ }
+ }
+ }
+ return Future.value(resultId);
+ }
+
+ @override
+ Future<List<Document>> findActiveResults(
+ String name, String configuration) async {
+ return [
+ for (final id in results.keys)
+ if (results[id][fName] == name &&
+ results[id][fActiveConfigurations] != null &&
+ results[id][fActiveConfigurations].contains(configuration))
+ Document.fromJson({'fields': taggedJsonMap(Map.from(results[id]))})
+ ..name = id
+ ];
+ }
+
+ @override
+ Future<void> storeResult(Map<String, dynamic> result) async {
+ final id = 'resultDocumentID$addedResultIdCounter';
+ addedResultIdCounter++;
+ results[id] = result;
+ }
+
+ @override
+ Future<bool> updateResult(
+ String resultId, String configuration, int startIndex, int endIndex,
+ {bool failure}) {
+ final result = Map<String, dynamic>.from(results[resultId]);
+
+ result[fBlamelistStartIndex] =
+ max<int>(startIndex, result[fBlamelistStartIndex]);
+
+ result[fBlamelistEndIndex] = min<int>(endIndex, result[fBlamelistEndIndex]);
+ if (!result[fConfigurations].contains(configuration)) {
+ result[fConfigurations] = List<String>.from(result[fConfigurations])
+ ..add(configuration)
+ ..sort();
+ }
+ if (failure) {
+ result[fActive] = true;
+ if (!result[fActiveConfigurations].contains(configuration)) {
+ result[fActiveConfigurations] =
+ List<String>.from(result[fActiveConfigurations])
+ ..add(configuration)
+ ..sort();
+ }
+ }
+ results[resultId] = result;
+ return Future.value(result[fApproved] ?? false);
+ }
+
+ @override
+ Future<void> updateActiveResult(
+ Document activeResult, String configuration) async {
+ final result = Map<String, dynamic>.from(results[activeResult.name]);
+ result[fActiveConfigurations] = List.from(result[fActiveConfigurations])
+ ..remove(configuration);
+ if (result[fActiveConfigurations].isEmpty) {
+ result.remove(fActiveConfigurations);
+ result.remove(fActive);
+ }
+ results[activeResult.name] = result;
+ }
+
+ @override
+ Future<List<Map<String, Value>>> findRevertedChanges(int index) async {
+ return results.values
+ .where((change) =>
+ change[fPinnedIndex] == index ||
+ (change[fBlamelistStartIndex] == index &&
+ change[fBlamelistEndIndex] == index))
+ .map(taggedMap)
+ .toList();
+ }
+
+ @override
+ Future<List<Map<String, Value>>> tryApprovals(int review) async {
+ return fakeTryResults
+ .where(
+ (result) => result[fReview] == review && result[fApproved] == true)
+ .map(taggedMap)
+ .toList();
+ }
+
+ @override
+ Future<List<Map<String, Value>>> tryResults(
+ int review, String configuration) async {
+ return fakeTryResults
+ .where((result) =>
+ result[fReview] == review &&
+ result[fConfigurations].contains(configuration))
+ .map(taggedMap)
+ .toList();
+ }
+
+ @override
+ Future<bool> reviewIsLanded(int review) =>
+ Future.value(commits.values.any((commit) => commit[fReview] == review));
+}
+
+class HttpClientMock extends Mock implements BaseClient {}
+
+class ResponseFake extends Fake implements Response {
+ @override
+ String body;
+ ResponseFake(this.body);
+}
diff --git a/builder/test/firestore_test.dart b/builder/test/firestore_test.dart
new file mode 100644
index 0000000..e500310
--- /dev/null
+++ b/builder/test/firestore_test.dart
@@ -0,0 +1,139 @@
+// 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.
+
+// import 'package:firebase_admin_interop/firebase_admin_interop.dart';
+// import 'package:firebase_functions_interop/firebase_functions_interop.dart';
+import 'package:builder/src/firestore.dart';
+import 'package:test/test.dart';
+import 'package:builder/src/tryjob.dart';
+import 'package:googleapis_auth/auth_io.dart';
+import 'package:http/http.dart' as http;
+import 'package:googleapis/firestore/v1.dart';
+
+import 'test_data.dart';
+
+// These tests read and write data from the Firestore database, and
+// should only be run locally against the dart-ci-staging project.
+// Requires the environment variable GOOGLE_APPLICATION_CREDENTIALS
+// to point to a json key to a service account
+// with write access to dart_ci_staging datastore.
+// Set the database with 'firebase use --add dart-ci-staging'
+// The test must be compiled with nodejs, and run using the 'node' command.
+
+void main() async {
+ final baseClient = http.Client();
+ final client = await clientViaApplicationDefaultCredentials(
+ scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+ baseClient: baseClient);
+ final api = FirestoreApi(client);
+ final firestore = FirestoreService(api, client);
+ if (!await firestore.isStaging()) {
+ throw (TestFailure(
+ 'Error: firestore_test_nodejs.dart is being run on production'));
+ }
+
+ const testReviewDocument =
+ 'projects/dart-ci-staging/databases/(default)/documents/reviews/$testReview';
+
+ tearDownAll(() => baseClient.close());
+
+ group('Try results', () {
+ setUp(() async {
+ if (await firestore.documentExists(testReviewDocument)) {
+ await firestore.deleteDocument(testReviewDocument);
+ }
+ });
+
+ tearDown(() async {
+ // Delete database records created by the tests.
+ var snapshot = await firestore.query(
+ from: 'try_builds', where: fieldEquals('review', testReview));
+ for (final doc in snapshot) {
+ if (doc.document != null) {
+ await firestore.deleteDocument(doc.document.name);
+ }
+ }
+ snapshot =
+ // await firestore.collection('reviews/$testReview/patchsets').get();
+ await firestore.query(
+ from: 'patchsets', parent: 'reviews/$testReview/');
+ for (final doc in snapshot) {
+ if (doc.document != null) {
+ await firestore.deleteDocument(doc.document.name);
+ }
+ }
+ await firestore.deleteDocument(testReviewDocument);
+ });
+
+ test('approved try result fetching', () async {
+ await firestore.storeReview(testReview.toString(), {
+ 'subject': 'test review: approved try result fetching',
+ });
+ await firestore.storePatchset(
+ testReview.toString(),
+ 1,
+ 'REWORK',
+ 'Initial upload',
+ 1,
+ 1,
+ );
+ await firestore.storePatchset(
+ testReview.toString(),
+ 2,
+ 'REWORK',
+ 'change',
+ 2,
+ 2,
+ );
+ await firestore.storePatchset(
+ testReview.toString(),
+ 3,
+ 'NO_CODE_CHANGE',
+ 'Edit commit message',
+ 2,
+ 3,
+ );
+ final tryResult = {
+ 'review': testReview,
+ 'configuration': 'test_configuration',
+ 'name': 'test_suite/test_name',
+ 'patchset': 1,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'previous_result': 'Pass',
+ };
+ await firestore.storeTryChange(tryResult, testReview, 1);
+ final tryResult2 = Map<String, dynamic>.from(tryResult);
+ tryResult2['patchset'] = 2;
+ tryResult2['name'] = 'test_suite/test_name_2';
+ await firestore.storeTryChange(tryResult2, testReview, 2);
+ tryResult['patchset'] = 3;
+ tryResult['name'] = 'test_suite/test_name';
+ tryResult['expected'] = 'CompileTimeError';
+ await firestore.storeTryChange(tryResult, testReview, 3);
+ // Set the results on patchsets 1 and 2 to approved.
+ final snapshot = await firestore.query(
+ from: 'try_results',
+ where: compositeFilter([
+ fieldEquals('approved', false),
+ fieldEquals('review', testReview),
+ fieldLessThanOrEqual('patchset', 2)
+ ]));
+ for (final response in snapshot) {
+ await firestore.approveResult(response.document);
+ //await firestore.updateDocument(response.document.name, {'approved': taggedValue(true)});
+ }
+
+ // Should return only the approved change on patchset 2,
+ // not the one on patchset 1 or the unapproved change on patchset 3.
+ final approvals = await firestore.tryApprovals(testReview);
+ tryResult2['configurations'] = [tryResult2['configuration']];
+ tryResult2['approved'] = true;
+ tryResult2.remove('configuration');
+ expect(1, approvals.length);
+ final approval = untagMap(approvals.single);
+ expect(approval, tryResult2);
+ });
+ });
+}
diff --git a/builder/test/gerrit_review_json.dart b/builder/test/gerrit_review_json.dart
new file mode 100644
index 0000000..2da5c32
--- /dev/null
+++ b/builder/test/gerrit_review_json.dart
@@ -0,0 +1,109 @@
+// Copyright (c) 2020, 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.
+
+// This is the JSON log for an actual review that is a revert,
+// with emails and names removed.
+String revertReviewGerritLog = r'''
+{
+ "id": "sdk~master~Ie212fae88bc1977e34e4d791c644b77783a8deb1",
+ "project": "sdk",
+ "branch": "master",
+ "hashtags": [],
+ "change_id": "Ie212fae88bc1977e34e4d791c644b77783a8deb1",
+ "subject": "Revert \"[SDK] Adds IndirectGoto implementation of sync-yield.\"",
+ "status": "MERGED",
+ "created": "2020-02-17 12:17:05.000000000",
+ "updated": "2020-02-17 12:17:25.000000000",
+ "submitted": "2020-02-17 12:17:25.000000000",
+ "submitter": {
+ "_account_id": 5260,
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org"
+ },
+ "insertions": 61,
+ "deletions": 155,
+ "total_comment_count": 0,
+ "unresolved_comment_count": 0,
+ "has_review_started": true,
+ "revert_of": 133586,
+ "submission_id": "136125",
+ "_number": 136125,
+ "owner": {
+ },
+ "current_revision": "82f3f81fc82d06c575b0137ddbe71408826d8b46",
+ "revisions": {
+ "82f3f81fc82d06c575b0137ddbe71408826d8b46": {
+ "kind": "REWORK",
+ "_number": 2,
+ "created": "2020-02-17 12:17:25.000000000",
+ "uploader": {
+ "_account_id": 5260,
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org"
+ },
+ "ref": "refs/changes/25/136125/2",
+ "fetch": {
+ "rpc": {
+ "url": "rpc://dart/sdk",
+ "ref": "refs/changes/25/136125/2"
+ },
+ "http": {
+ "url": "https://dart.googlesource.com/sdk",
+ "ref": "refs/changes/25/136125/2"
+ },
+ "sso": {
+ "url": "sso://dart/sdk",
+ "ref": "refs/changes/25/136125/2"
+ }
+ },
+ "commit": {
+ "parents": [
+ {
+ "commit": "d2d00ff357bd64a002697b3c96c92a0fec83328c",
+ "subject": "[cfe] Allow unassigned late local variables"
+ }
+ ],
+ "author": {
+ "name": "gerrit_user",
+ "email": "gerrit_user@example.com",
+ "date": "2020-02-17 12:17:25.000000000",
+ "tz": 0
+ },
+ "committer": {
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org",
+ "date": "2020-02-17 12:17:25.000000000",
+ "tz": 0
+ },
+ "subject": "Revert \"[SDK] Adds IndirectGoto implementation of sync-yield.\"",
+ "message": "Revert \"[SDK] Adds IndirectGoto implementation of sync-yield.\"\n\nThis reverts commit 7ed1690b4ed6b56bc818173dff41a7a2530991a2.\n\nReason for revert: Crashes precomp.\n\nOriginal change\u0027s description:\n\u003e [SDK] Adds IndirectGoto implementation of sync-yield.\n\u003e \n\u003e Sets a threshold of five continuations determining if the old\n\u003e if-else or the new igoto-based implementation will be used.\n\u003e Informal benchmarking on x64 and arm_x64 point towards the overhead\n\u003e of the igoto-based impl. dropping off around this point.\n\u003e \n\u003e Benchmarks of this CL (threshold\u003d5) show drastic improvement in\n\u003e Calls.IterableManualIterablePolymorphicManyYields of about ~35-65%\n\u003e across {dart,dart-aot}-{ia32,x64,armv7hf,armv8}.\n\u003e \n\u003e Bug: https://github.com/dart-lang/sdk/issues/37754\n\u003e Change-Id: I6e113f1f98e9ab0f994cf93004227d616e9e4d07\n\u003e Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/133586\n\u003e Commit-Queue: XXXXX \u003cxxxx@example.com\u003e\n\u003e Reviewed-by: xxxx \u003cxxxxxx@example.com\u003e\n\nChange-Id: Ie212fae88bc1977e34e4d791c644b77783a8deb1\nNo-Presubmit: true\nNo-Tree-Checks: true\nNo-Try: true\nBug: https://github.com/dart-lang/sdk/issues/37754\nReviewed-on: https://dart-review.googlesource.com/c/sdk/+/136125\nReviewed-by: XXX\nCommit-Queue: XXXXXX\n"
+ },
+ "description": "Rebase"
+ },
+ "8bae95c4001a0815e89ebc4c89dc5ad42337a01b": {
+ "kind": "REWORK",
+ "_number": 1,
+ "created": "2020-02-17 12:17:05.000000000",
+ "uploader": {
+ },
+ "ref": "refs/changes/25/136125/1",
+ "fetch": {
+ "rpc": {
+ "url": "rpc://dart/sdk",
+ "ref": "refs/changes/25/136125/1"
+ },
+ "http": {
+ "url": "https://dart.googlesource.com/sdk",
+ "ref": "refs/changes/25/136125/1"
+ },
+ "sso": {
+ "url": "sso://dart/sdk",
+ "ref": "refs/changes/25/136125/1"
+ }
+ }
+ }
+ },
+ "requirements": []
+}
+''';
diff --git a/builder/test/test.dart b/builder/test/test.dart
new file mode 100644
index 0000000..3acd649
--- /dev/null
+++ b/builder/test/test.dart
@@ -0,0 +1,94 @@
+// 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.
+
+import 'package:builder/src/firestore.dart';
+import 'package:mockito/mockito.dart';
+import 'package:test/test.dart';
+
+import 'package:builder/src/result.dart';
+import 'fakes.dart';
+import 'test_data.dart';
+
+void main() async {
+ test('Base builder test', () async {
+ final builderTest = BuilderTest(landedCommitHash, landedCommitChange);
+ await builderTest.update();
+ });
+
+ test('Get info for already saved commit', () async {
+ final builderTest = BuilderTest(existingCommitHash, existingCommitChange);
+ await builderTest.storeBuildCommitsInfo();
+ expect(builderTest.builder.endIndex, existingCommitIndex);
+ expect(builderTest.builder.startIndex, previousCommitIndex + 1);
+ });
+
+ test('Link landed commit to review', () async {
+ final builderTest = BuilderTest(landedCommitHash, landedCommitChange);
+ builderTest.firestore.commits
+ .removeWhere((key, value) => value[fIndex] > existingCommitIndex);
+ when(builderTest.client.get(any))
+ .thenAnswer((_) => Future(() => ResponseFake(gitilesLog)));
+ await builderTest.storeBuildCommitsInfo();
+ await builderTest.builder.fetchReviewsAndReverts();
+ expect(builderTest.builder.endIndex, landedCommitIndex);
+ expect(builderTest.builder.startIndex, existingCommitIndex + 1);
+ expect(builderTest.builder.tryApprovals,
+ {testResult(review44445Result): 54, testResult(review77779Result): 53});
+ expect((await builderTest.firestore.getCommit(commit53Hash)).toJson(),
+ commit53);
+ expect((await builderTest.firestore.getCommit(landedCommitHash)).toJson(),
+ landedCommit);
+ });
+
+ test('update previous active result', () async {
+ final builderTest = BuilderTest(landedCommitHash, landedCommitChange);
+ await builderTest.storeBuildCommitsInfo();
+ await builderTest.storeChange(landedCommitChange);
+ expect(builderTest.builder.success, true);
+ expect(
+ builderTest.firestore.results['activeResultID'],
+ Map.from(activeResult)
+ ..[fActiveConfigurations] = ['another configuration']);
+
+ final changeAnotherConfiguration =
+ Map<String, dynamic>.from(landedCommitChange)
+ ..['configuration'] = 'another configuration';
+ await builderTest.storeChange(changeAnotherConfiguration);
+ expect(builderTest.builder.success, true);
+ expect(builderTest.firestore.results['activeResultID'],
+ Map.from(activeResult)..remove(fActiveConfigurations)..remove(fActive));
+ expect(builderTest.builder.countApprovalsCopied, 1);
+ expect(builderTest.builder.countChanges, 2);
+ expect(
+ builderTest.firestore.results[await builderTest.firestore.findResult(
+ landedCommitChange, landedCommitIndex, landedCommitIndex)],
+ landedResult);
+ final result = (await builderTest.firestore.findActiveResults(
+ landedCommitChange['name'], landedCommitChange['configuration']))
+ .single;
+ expect(untagMap(result.fields), landedResult);
+ });
+
+ test('mark active result flaky', () async {
+ final builderTest = BuilderTest(landedCommitHash, landedCommitChange);
+ await builderTest.storeBuildCommitsInfo();
+ final flakyChange = Map<String, dynamic>.from(landedCommitChange)
+ ..[fPreviousResult] = 'RuntimeError'
+ ..[fFlaky] = true;
+ expect(flakyChange[fResult], 'RuntimeError');
+ await builderTest.storeChange(flakyChange);
+ expect(flakyChange[fResult], 'flaky');
+ expect(builderTest.builder.success, true);
+ expect(
+ builderTest.firestore.results['activeResultID'],
+ Map.from(activeResult)
+ ..[fActiveConfigurations] = ['another configuration']);
+
+ expect(builderTest.builder.countChanges, 1);
+ expect(
+ builderTest.firestore.results[await builderTest.firestore
+ .findResult(flakyChange, landedCommitIndex, landedCommitIndex)],
+ flakyResult);
+ });
+}
diff --git a/builder/test/test_data.dart b/builder/test/test_data.dart
new file mode 100644
index 0000000..545861f
--- /dev/null
+++ b/builder/test/test_data.dart
@@ -0,0 +1,341 @@
+// 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.
+
+import 'dart:core';
+
+Map<String, dynamic> fakeFirestoreCommits = Map.unmodifiable({
+ previousCommitHash: previousCommit, // 51
+ existingCommitHash: existingCommit, // 52
+ commit53Hash: commit53, // 53
+ landedCommitHash: landedCommit, // 54
+});
+const fakeFirestoreCommitsFirstIndex = previousCommitIndex;
+const fakeFirestoreCommitsLastIndex = landedCommitIndex;
+
+Map<String, Map<String, dynamic>> fakeFirestoreResults = Map.unmodifiable({
+ 'activeFailureResultID': activeFailureResult,
+ 'activeResultID': activeResult,
+});
+
+const List<Map<String, dynamic>> fakeFirestoreTryResults = [
+ review44445Result,
+ review77779Result,
+];
+
+// Test commits. These are test commit documents from Firestore.
+// When they are returned from the FirestoreService API, their hash
+// is added to the map with key 'hash'.
+const String previousCommitHash = 'a previous existing commit hash';
+const int previousCommitIndex = 51;
+Map<String, dynamic> previousCommit = Map.unmodifiable({
+ 'author': 'previous_user@example.com',
+ 'created': DateTime.parse('2019-11-24 11:18:00Z'),
+ 'index': previousCommitIndex,
+ 'title': 'A commit used for testing, with index 51',
+ 'hash': previousCommitHash,
+});
+
+const String existingCommitHash = 'an already existing commit hash';
+const int existingCommitIndex = 52;
+Map<String, dynamic> existingCommit = Map.unmodifiable({
+ 'author': 'test_user@example.com',
+ 'created': DateTime.parse('2019-11-22 22:19:00Z'),
+ 'index': existingCommitIndex,
+ 'title': 'A commit used for testing, with index 52',
+ 'hash': existingCommitHash,
+});
+
+const String commit53Hash = 'commit 53 landing CL 77779 hash';
+const int commit53Index = 53;
+Map<String, dynamic> commit53 = Map.unmodifiable({
+ 'author': 'user@example.com',
+ 'created': DateTime.parse('2019-11-28 12:07:55 +0000'),
+ 'index': commit53Index,
+ 'title': 'A commit on the git log',
+ 'hash': commit53Hash,
+ 'review': 77779,
+});
+
+const String landedCommitHash = 'a commit landing a CL hash';
+const int landedCommitIndex = 54;
+Map<String, dynamic> landedCommit = Map.unmodifiable({
+ 'author': 'gerrit_user@example.com',
+ 'created': DateTime.parse('2019-11-29 15:15:00Z'),
+ 'index': landedCommitIndex,
+ 'title': 'A commit used for testing tryjob approvals, with index 54',
+ 'hash': landedCommitHash,
+ 'review': 44445
+});
+
+/// Changes
+/// These are single lines from a result.json, representing the output
+/// of a single test on a single configuration on a single build.
+const String sampleTestName = 'local_function_signatures_strong_test/none';
+const String sampleTestSuite = 'dart2js_extra';
+const String sampleTest = '$sampleTestSuite/$sampleTestName';
+
+const Map<String, dynamic> existingCommitChange = {
+ 'name': sampleTest,
+ 'configuration': 'dart2js-new-rti-linux-x64-d8',
+ 'suite': sampleTestSuite,
+ 'test_name': sampleTestName,
+ 'time_ms': 2384,
+ 'result': 'Pass',
+ 'expected': 'Pass',
+ 'matches': true,
+ 'bot_name': 'luci-dart-try-xenial-70-8fkh',
+ 'commit_hash': existingCommitHash,
+ 'commit_time': 1563576771,
+ 'build_number': '307',
+ 'builder_name': 'dart2js-rti-linux-x64-d8',
+ 'flaky': false,
+ 'previous_flaky': false,
+ 'previous_result': 'RuntimeError',
+ 'previous_commit_hash': previousCommitHash,
+ 'previous_commit_time': 1563576211,
+ 'previous_build_number': '306',
+ 'changed': true
+};
+
+const Map<String, dynamic> landedCommitChange = {
+ 'name': sampleTest,
+ 'configuration': 'dart2js-new-rti-linux-x64-d8',
+ 'suite': sampleTestSuite,
+ 'test_name': sampleTestName,
+ 'time_ms': 2384,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'matches': false,
+ 'bot_name': 'luci-dart-try-xenial-70-8fkh',
+ 'commit_hash': landedCommitHash,
+ 'commit_time': 1563576771,
+ 'build_number': '308',
+ 'builder_name': 'dart2js-rti-linux-x64-d8',
+ 'flaky': false,
+ 'previous_flaky': false,
+ 'previous_result': 'Pass',
+ 'previous_commit_hash': existingCommitHash,
+ 'previous_commit_time': 1563576211,
+ 'previous_build_number': '306',
+ 'changed': true
+};
+
+/// Results
+/// These are test Result documents, as stored in Firestore.
+const Map<String, dynamic> activeFailureResult = {
+ 'name': 'test_suite/active_failing_test',
+ 'configurations': [testConfiguration, 'configuration 2', 'configuration 3'],
+ 'active': true,
+ 'active_configurations': [testConfiguration, 'configuration 2'],
+ 'approved': false,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'previous_result': 'Pass',
+ 'blamelist_start_index': 67195,
+ 'blamelist_end_index': 67195
+};
+
+// A result on existingCommit that is overridden by the new result in
+// landedCommitChange.
+Map<String, dynamic> activeResult = {
+ 'name': sampleTest,
+ 'blamelist_start_index': existingCommitIndex,
+ 'blamelist_end_index': existingCommitIndex,
+ 'configurations': [
+ landedCommitChange['configuration'],
+ 'another configuration'
+ ]..sort(),
+ 'active_configurations': [
+ landedCommitChange['configuration'],
+ 'another configuration'
+ ]..sort(),
+ 'active': true,
+ 'approved': false,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'previous_result': 'Pass',
+};
+
+Map<String, dynamic> landedResult = {
+ 'name': sampleTest,
+ 'blamelist_start_index': existingCommitIndex + 1,
+ 'blamelist_end_index': landedCommitIndex,
+ 'pinned_index': landedCommitIndex,
+ 'configurations': [
+ 'another configuration',
+ landedCommitChange['configuration'],
+ ]..sort(),
+ 'active_configurations': [
+ landedCommitChange['configuration'],
+ 'another configuration'
+ ]..sort(),
+ 'active': true,
+ 'approved': true,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'previous_result': 'Pass',
+};
+
+Map<String, dynamic> flakyResult = {
+ 'name': sampleTest,
+ 'blamelist_start_index': existingCommitIndex + 1,
+ 'blamelist_end_index': landedCommitIndex,
+ 'configurations': [landedCommitChange['configuration']],
+ 'approved': false,
+ 'result': 'flaky',
+ 'expected': 'Pass',
+ 'previous_result': 'RuntimeError',
+};
+
+/// Try results
+/// These are documents from the try_results table in Firestore.
+const Map<String, dynamic> review44445Result = {
+ 'review': 44445,
+ 'configurations': [
+ 'dart2js-new-rti-linux-x64-d8',
+ 'dartk-reload-rollback-linux-debug-x64',
+ 'dartk-reload-linux-debug-x64'
+ ],
+ 'name': sampleTest,
+ 'patchset': 1,
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'previous_result': 'Pass',
+ 'approved': true
+};
+const Map<String, dynamic> review77779Result = {
+ 'review': 77779,
+ 'configurations': ['test_configuration'],
+ 'name': 'test_suite/test_name',
+ 'patchset': 5,
+ 'result': 'RuntimeError',
+ 'expected': 'CompileTimeError',
+ 'previous_result': 'CompileTimeError',
+ 'approved': true
+};
+
+const testBuilder = 'test_builder';
+const testBuildNumber = '308';
+const tryjob2BuildNumber = '309';
+const tryjob3BuildNumber = '310';
+const testConfiguration = 'test_configuration';
+const testReview = 123;
+const testPatchset = 3;
+const testPreviousPatchset = 1;
+const testReviewPath = 'refs/changes/$testReview/$testPatchset';
+const testPreviousPatchsetPath =
+ 'refs/changes/$testReview/$testPreviousPatchset';
+const Map<String, dynamic> tryjobFailingChange = {
+ 'name': 'test_suite/failing_test',
+ 'configuration': 'test_configuration',
+ 'suite': 'test_suite',
+ 'test_name': 'failing_test',
+ 'time_ms': 2384,
+ 'result': 'CompileTimeError',
+ 'expected': 'Pass',
+ 'matches': false,
+ 'bot_name': 'test_bot',
+ 'commit_hash': testReviewPath,
+ 'commit_time': 1563576771,
+ 'build_number': testBuildNumber,
+ 'builder_name': testBuilder,
+ 'flaky': false,
+ 'previous_flaky': false,
+ 'previous_result': 'Pass',
+ 'previous_commit_hash': existingCommitHash,
+ 'previous_commit_time': 1563576211,
+ 'previous_build_number': '1234',
+ 'changed': true
+};
+
+final Map<String, dynamic> tryjob2OtherFailingChange =
+ Map<String, dynamic>.from(tryjobFailingChange)
+ ..addAll({
+ 'name': 'test_suite/other_failing_test',
+ 'test_name': 'other_failing_test',
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'matches': false,
+ 'previous_result': 'Pass',
+ 'changed': true,
+ 'build_number': tryjob2BuildNumber,
+ });
+
+final Map<String, dynamic> tryjobExistingFailure =
+ Map<String, dynamic>.from(tryjobFailingChange)
+ ..addAll({
+ 'name': 'test_suite/existing_failure_test',
+ 'test_name': 'passing_test',
+ 'result': 'RuntimeError',
+ 'expected': 'Pass',
+ 'matches': false,
+ 'previous_result': 'RuntimeError',
+ 'changed': false
+ });
+
+final Map<String, dynamic> tryjob2ExistingFailure =
+ Map<String, dynamic>.from(tryjobExistingFailure)
+ ..addAll({
+ 'build_number': tryjob2BuildNumber,
+ });
+
+final Map<String, dynamic> tryjob2FailingChange =
+ Map<String, dynamic>.from(tryjobFailingChange)
+ ..addAll({
+ 'build_number': tryjob2BuildNumber,
+ });
+
+final Map<String, dynamic> tryjobPassingChange =
+ Map<String, dynamic>.from(tryjobFailingChange)
+ ..addAll({
+ 'name': 'test_suite/passing_test',
+ 'test_name': 'passing_test',
+ 'result': 'Pass',
+ 'expected': 'Pass',
+ 'matches': true,
+ 'previous_result': 'RuntimeError',
+ 'changed': true
+ });
+
+final Map<String, dynamic> tryjob2PassingChange =
+ Map<String, dynamic>.from(tryjobPassingChange)
+ ..addAll({
+ 'build_number': tryjob2BuildNumber,
+ });
+
+final Map<String, dynamic> tryjob3PassingChange =
+ Map<String, dynamic>.from(tryjobPassingChange)
+ ..addAll({
+ 'build_number': tryjob3BuildNumber,
+ });
+
+String gitilesLog = '''
+)]}'
+{
+ "log": [
+ {
+ "commit": "$landedCommitHash",
+ "parents": ["$commit53Hash"],
+ "author": {
+ "email": "gerrit_user@example.com"
+ },
+ "committer": {
+ "time": "Fri Nov 29 15:15:00 2019 +0000"
+ },
+ "message": "A commit used for testing tryjob approvals, with index 54\\n\\nDescription of the landed commit\\nin multiple lines.\\n\\u003e Change-Id: I8dcc08b7571137e869a16ceea8cc73539eb02a5a\\n\\u003e Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/33337\\n\\nChange-Id: I89b88c3d9f7c743fc340ee73a45c3f57059bcf30\\nReviewed-on: https://dart-review.googlesource.com/c/sdk/+/44445\\n\\n"
+ },
+ {
+ "commit": "$commit53Hash",
+ "parents": ["$existingCommitHash"],
+ "author": {
+ "email": "user@example.com"
+ },
+ "committer": {
+ "time": "Thu Nov 28 12:07:55 2019 +0000"
+ },
+ "message": "A commit on the git log\\n\\nThis commit does not have results from the CQ\\n\\nChange-Id: I481b2cb8b666885b5c2b9c53fff1177accd01830\\nReviewed-on: https://dart-review.googlesource.com/c/sdk/+/77779\\nCommit-Queue: A user \\u003cuser9@example.com\\u003e\\nReviewed-by: Another user \\u003cuser10@example.com\\u003e\\n"
+ }
+ ]
+}
+''';
diff --git a/builder/test/test_gerrit.dart b/builder/test/test_gerrit.dart
new file mode 100644
index 0000000..9aaf399
--- /dev/null
+++ b/builder/test/test_gerrit.dart
@@ -0,0 +1,17 @@
+// Copyright (c) 2020, 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:test/test.dart';
+
+import 'package:builder/src/gerrit_change.dart';
+import 'gerrit_review_json.dart';
+
+void main() async {
+ test('get revert information from Gerrit log api output', () {
+ expect(GerritInfo.revert(json.decode(revertReviewGerritLog)),
+ '7ed1690b4ed6b56bc818173dff41a7a2530991a2');
+ });
+}
diff --git a/builder/test/test_revert.dart b/builder/test/test_revert.dart
new file mode 100644
index 0000000..7090714
--- /dev/null
+++ b/builder/test/test_revert.dart
@@ -0,0 +1,323 @@
+// Copyright (c) 2020, 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.
+
+// Tests that check automatic approval of failures on a revert on the CI
+
+import 'package:builder/src/firestore.dart';
+import 'package:mockito/mockito.dart';
+import 'package:test/test.dart';
+
+import 'package:builder/src/result.dart';
+import 'fakes.dart';
+import 'test_data.dart';
+
+void main() async {
+ test('fetch commit that is a revert', () async {
+ final builderTest = BuilderTest(revertCommitHash, revertUnchangedChange);
+ builderTest.firestore.commits[revertedCommitHash] = revertedCommit;
+ when(builderTest.client.get(any))
+ .thenAnswer((_) => Future(() => ResponseFake(revertGitilesLog)));
+ await builderTest.storeBuildCommitsInfo();
+ expect(builderTest.builder.endIndex, revertCommit['index']);
+ expect(builderTest.builder.startIndex, landedCommit['index'] + 1);
+ expect(
+ (await builderTest.builder.firestore.getCommit(revertCommitHash))
+ .toJson(),
+ revertCommit);
+ });
+
+ test('fetch commit that is a reland (as a reland)', () async {
+ final builderTest = BuilderTest(relandCommitHash, relandUnchangedChange);
+ builderTest.firestore.commits[revertedCommitHash] = revertedCommit;
+ when(builderTest.client.get(any)).thenAnswer(
+ (_) => Future(() => ResponseFake(revertAndRelandGitilesLog)));
+ await builderTest.storeBuildCommitsInfo();
+ expect(builderTest.builder.endIndex, relandCommit['index']);
+ expect(builderTest.builder.startIndex, revertCommit['index'] + 1);
+ expect(
+ (await builderTest.builder.firestore.getCommit(revertCommitHash))
+ .toJson(),
+ revertCommit);
+ expect(
+ (await builderTest.builder.firestore.getCommit(commit56Hash)).toJson(),
+ commit56);
+ expect(
+ (await builderTest.builder.firestore.getCommit(relandCommitHash))
+ .toJson(),
+ relandCommit);
+ });
+
+ test('fetch commit that is a reland (as a revert)', () async {
+ final builderTest =
+ RevertBuilderTest(relandCommitHash, relandUnchangedChange);
+ when(builderTest.client.get(any))
+ .thenAnswer((_) => Future(() => ResponseFake(relandGitilesLog)));
+ await builderTest.storeBuildCommitsInfo();
+ expect(builderTest.builder.endIndex, relandCommit['index']);
+ expect(builderTest.builder.startIndex, revertCommit['index'] + 1);
+ expect(
+ (await builderTest.builder.firestore.getCommit(relandCommitHash))
+ .toJson(),
+ relandCommit);
+ });
+
+ test('Automatically approve expected failure on revert', () async {
+ final builderTest = RevertBuilderTest(revertCommitHash, revertChange);
+ await builderTest.update();
+ await builderTest.storeChange(revertChange);
+ expect(
+ builderTest.firestore.results.values
+ .where((result) => result[fBlamelistEndIndex] == 55)
+ .single,
+ revertResult);
+ });
+
+ test('Revert in blamelist, doesn\'t match new failure', () async {
+ final builderTest =
+ RevertBuilderTest(commit56Hash, commit56UnmatchingChange);
+ await builderTest.update();
+ await builderTest.storeChange(commit56UnmatchingChange);
+ await builderTest.storeChange(commit56DifferentNameChange);
+ await builderTest.storeChange(commit56Change);
+
+ Future<bool> findApproval(Map<String, dynamic> change) async {
+ final result = await builderTest.firestore
+ .findActiveResults(change['name'], change['configuration']);
+ return ResultRecord(result.single.fields).approved;
+ }
+
+ expect(await findApproval(commit56UnmatchingChange), false);
+ expect(await findApproval(commit56DifferentNameChange), false);
+ expect(await findApproval(commit56Change), true);
+ });
+}
+
+class RevertBuilderTest extends BuilderTest {
+ RevertBuilderTest(String commitHash, Map<String, dynamic> firstChange)
+ : super(commitHash, firstChange) {
+ expect(revertedCommit[fIndex] + 1, fakeFirestoreCommitsFirstIndex);
+ expect(revertCommit[fIndex] - 1, fakeFirestoreCommitsLastIndex);
+ firestore.commits
+ ..[revertedCommitHash] = revertedCommit
+ ..[revertCommitHash] = revertCommit
+ ..[commit56Hash] = commit56;
+ firestore.results['revertedResult id'] = revertedResult;
+ }
+}
+
+// Commits
+const String revertedCommitHash = '50abcd55abcd';
+const int revertedReview = 3926;
+const int revertedIndex = 50;
+Map<String, dynamic> revertedCommit = Map.unmodifiable({
+ 'author': 'gerrit_reverted_user@example.com',
+ 'created': DateTime.parse('2019-11-22 02:01:00Z'),
+ 'index': revertedIndex,
+ 'title': 'A commit reverted by commit 55, with index 50',
+ 'review': revertedReview,
+ 'hash': revertedCommitHash,
+});
+
+const String revertCommitHash = '55ffffdddd';
+const int revertReview = 3426;
+const int revertIndex = 55;
+Map<String, dynamic> revertCommit = Map.unmodifiable({
+ 'author': 'gerrit_revert_user@example.com',
+ 'created': DateTime.parse('2019-11-29 16:15:00Z'),
+ 'index': revertIndex,
+ 'title': 'Revert "${revertedCommit[fTitle]}"',
+ 'hash': revertCommitHash,
+ 'review': revertReview,
+ 'revert_of': revertedCommitHash,
+});
+
+const String commit56Hash = '56ffeeddccbbaa00';
+Map<String, dynamic> commit56 = Map.unmodifiable({
+ 'author': 'gerrit_revert_user@example.com',
+ 'created': DateTime.parse('2019-11-29 17:15:00Z'),
+ 'index': revertIndex + 1,
+ 'title': 'A commit with index 56',
+ 'hash': commit56Hash,
+});
+
+const String relandCommitHash = '57eeddccff7733';
+const int relandReview = 98999;
+Map<String, dynamic> relandCommit = Map.unmodifiable({
+ 'author': 'gerrit_reland_user@example.com',
+ 'created': DateTime.parse('2020-01-13 06:16:00Z'),
+ 'index': revertIndex + 2,
+ 'title': 'Reland "${revertedCommit[fTitle]}"',
+ 'hash': relandCommitHash,
+ 'review': relandReview,
+ 'reland_of': revertedCommitHash,
+});
+
+// Changes
+// This change is an unchanged passing result, used as the first result in
+// a chunk with no changed results.
+const Map<String, dynamic> revertUnchangedChange = {
+ "name": "dart2js_extra/local_function_signatures_strong_test/none",
+ "configuration": "dart2js-new-rti-linux-x64-d8",
+ "suite": "dart2js_extra",
+ "test_name": "local_function_signatures_strong_test/none",
+ "time_ms": 2384,
+ "result": "Pass",
+ "expected": "Pass",
+ "matches": false,
+ "bot_name": "luci-dart-try-xenial-70-8fkh",
+ "commit_hash": revertCommitHash,
+ "previous_commit_hash": landedCommitHash,
+ "commit_time": 1563576771,
+ "build_number": "401",
+ "previous_build_number": "400",
+ "changed": false,
+};
+
+Map<String, dynamic> relandUnchangedChange = Map.from(revertUnchangedChange)
+ ..["commit_hash"] = relandCommitHash
+ ..["previous_commit_hash"] = revertCommitHash;
+
+const Map<String, dynamic> revertChange = {
+ "name": "test_suite/fixed_broken_test",
+ "configuration": "a_different_configuration",
+ "suite": "test_suite",
+ "test_name": "fixed_broken_test",
+ "time_ms": 2384,
+ "result": "RuntimeError",
+ "expected": "Pass",
+ "matches": false,
+ "bot_name": "a_ci_bot",
+ "commit_hash": revertCommitHash,
+ "commit_time": 1563576771,
+ "build_number": "314",
+ "builder_name": "dart2js-rti-linux-x64-d8",
+ "flaky": false,
+ "previous_flaky": false,
+ "previous_result": "Pass",
+ "previous_commit_hash": existingCommitHash,
+ "previous_commit_time": 1563576211,
+ "previous_build_number": "313",
+ "changed": true,
+};
+
+const Map<String, dynamic> revertedChange = {
+ "name": "test_suite/fixed_broken_test",
+ "configuration": "a_configuration",
+ "suite": "test_suite",
+ "test_name": "fixed_broken_test",
+ "time_ms": 2384,
+ "result": "Pass",
+ "expected": "Pass",
+ "matches": true,
+ "bot_name": "a_ci_bot",
+ "commit_hash": revertedCommitHash,
+ "commit_time": 1563576771,
+ "build_number": "308",
+ "builder_name": "dart2js-rti-linux-x64-d8",
+ "flaky": false,
+ "previous_flaky": false,
+ "previous_result": "RuntimeError",
+ "previous_commit_hash": "a nonexistent hash",
+ "previous_commit_time": 1563576211,
+ "previous_build_number": "306",
+ "changed": true
+};
+
+Map<String, dynamic> commit56Change = Map.from(revertChange)
+ ..['commit_hash'] = commit56Hash;
+Map<String, dynamic> commit56UnmatchingChange = Map.from(commit56Change)
+ ..['configuration'] = 'a_configuration'
+ ..['commit_hash'] = commit56Hash
+ ..['result'] = 'CompileTimeError';
+Map<String, dynamic> commit56DifferentNameChange = Map.from(commit56Change)
+ ..['commit_hash'] = commit56Hash
+ ..['name'] = 'test_suite/broken_test'
+ ..['test_name'] = 'broken_test';
+
+// Results
+const Map<String, dynamic> revertResult = {
+ "configurations": ["a_different_configuration"],
+ "active": true,
+ "active_configurations": ["a_different_configuration"],
+ "name": "test_suite/fixed_broken_test",
+ "result": "RuntimeError",
+ "expected": "Pass",
+ "previous_result": "Pass",
+ "blamelist_start_index": commit53Index,
+ "blamelist_end_index": revertIndex,
+ "pinned_index": revertIndex,
+ "approved": true,
+};
+
+const Map<String, dynamic> revertedResult = {
+ "configurations": ["a_configuration"],
+ "name": "test_suite/fixed_broken_test",
+ "result": "Pass",
+ "expected": "Pass",
+ "previous_result": "RuntimeError",
+ "blamelist_start_index": revertedIndex,
+ "blamelist_end_index": revertedIndex,
+};
+
+// Git logs
+String escape(s) => s.replaceAll('"', '\\"');
+String revertGitilesLog = gitilesLog([revertCommitJson]);
+String relandGitilesLog = gitilesLog([relandCommitJson(relandAsRevert)]);
+String revertAndRelandGitilesLog = gitilesLog(
+ [relandCommitJson(relandAsReland), commit56Json, revertCommitJson]);
+
+String gitilesLog(List<String> commitLogs) => '''
+)]}'
+{
+ "log": [
+ ${commitLogs.join(",\n")}
+ ]
+}
+''';
+
+String revertCommitJson = '''
+ {
+ "commit": "$revertCommitHash",
+ "parents": ["$landedCommitHash"],
+ "author": {
+ "email": "${revertCommit[fAuthor]}"
+ },
+ "committer": {
+ "time": "Fri Nov 29 16:15:00 2019 +0000"
+ },
+ "message": "${escape(revertCommit[fTitle])}\\n\\nThis reverts commit $revertedCommitHash.\\nChange-Id: I89b88c3d9f7c743fc340ee73a45c3f57059bcf30\\nReviewed-on: https://dart-review.googlesource.com/c/sdk/+/$revertReview\\n\\n"
+ }
+''';
+
+String commit56Json = '''
+ {
+ "commit": "$commit56Hash",
+ "parents": ["$revertCommitHash"],
+ "author": {
+ "email": "${commit56[fAuthor]}"
+ },
+ "committer": {
+ "time": "Fri Nov 29 17:15:00 2019 +0000"
+ },
+ "message": "${escape(commit56[fTitle])}\\n\\nNo line like: This reverts commit $revertedCommitHash.\\nChange-Id: I89b88c3d9f7c743fc340ee73a45c3f57059bcf30\\nNo review line either\\n\\n"
+ }
+''';
+
+String relandCommitJson(String relandLine) => '''
+ {
+ "commit": "$relandCommitHash",
+ "parents": ["$commit56Hash"],
+ "author": {
+ "email": "${relandCommit[fAuthor]}"
+ },
+ "committer": {
+ "time": "Mon Jan 13 06:16:00 2020 +0000"
+ },
+ "message": "${escape(relandCommit[fTitle])}\\n\\n$relandLine\\nChange-Id: I89b88c3d9f7c743fc340ee73a45c3f57059bcf30\\nReviewed-on: https://dart-review.googlesource.com/c/sdk/+/$relandReview\\n\\n"
+ }
+''';
+
+String relandAsRevert = "This reverts commit $revertCommitHash.";
+
+String relandAsReland = "This is a reland of $revertedCommitHash";
diff --git a/builder/test/tryjob_test.dart b/builder/test/tryjob_test.dart
new file mode 100644
index 0000000..a83b071
--- /dev/null
+++ b/builder/test/tryjob_test.dart
@@ -0,0 +1,377 @@
+// Copyright (c) 2020, 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 'package:builder/src/firestore.dart';
+import 'package:googleapis/firestore/v1.dart';
+import 'package:mockito/mockito.dart';
+import 'package:test/test.dart';
+
+import 'package:builder/src/firestore.dart' as fs;
+import 'package:builder/src/commits_cache.dart';
+import 'package:builder/src/tryjob.dart';
+import 'fakes.dart';
+import 'package:googleapis_auth/auth_io.dart';
+import 'package:http/http.dart' as http;
+
+// These tests read and write data from the staging Firestore database.
+// They create a fake review, and fake try builds against that review.
+// They attempt to remove these records in the cleanup, even if tests fail.
+// Requires the environment variable GOOGLE_APPLICATION_CREDENTIALS
+// to point to a json key to a service account.
+// To run against the staging database, use a service account.
+// with write access to dart_ci_staging datastore.
+// The test must be compiled with nodejs, and run using the 'node' command.
+
+const fakeReview = 123;
+const buildBaseCommit = 69191;
+const buildBaseCommitHash = 'b681bfd8d275b84b51f37919f0edc0d8563a870f';
+const buildBuildbucketId = 'a fake buildbucket ID';
+const ciResultsCommitIndex = 69188;
+const ciResultsCommitHash = '7b6adc6083c9918c826f5b82d25fdf6da9d90499';
+const reviewForCommit69190 = 138293;
+const patchsetForCommit69190 = 2;
+const tryBuildForCommit69190 = '99998';
+const reviewForCommit69191 = 138500;
+const patchsetForCommit69191 = 7;
+const tryBuildForCommit69191 = '99999';
+const earlierTryBuildsBaseCommit = '8ae984c54ab36a05422af6f250dbaa7da70fc461';
+const earlierTryBuildsResultsCommit = earlierTryBuildsBaseCommit;
+
+const fakeSuite = 'fake_test_suite';
+const fakeTestName = 'subdir/a_dart_test';
+const otherFakeTestName = 'another_dart_test';
+const fakeTest = '$fakeSuite/$fakeTestName';
+const otherFakeTest = '$fakeSuite/$otherFakeTestName';
+const fakeConfiguration = 'a configuration';
+const otherConfiguration = 'another configuration';
+const fakeBuilderName = 'fake_builder-try';
+
+Set<String> fakeBuilders = {fakeBuilderName};
+Set<String> fakeTests = {fakeTest, otherFakeTest};
+
+void registerChangeForDeletion(Map<String, dynamic> change) {
+ fakeBuilders.add(change['builder_name']);
+ fakeTests.add(change['name']);
+}
+
+fs.FirestoreService firestore;
+http.Client client;
+CommitsCache commitsCache;
+
+void main() async {
+ final baseClient = http.Client();
+ final mockClient = HttpClientMock();
+ addFakeReplies(mockClient);
+ client = await clientViaApplicationDefaultCredentials(
+ scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+ baseClient: baseClient);
+ final api = FirestoreApi(client);
+ firestore = FirestoreService(api, client);
+ if (!await firestore.isStaging()) {
+ throw (TestFailure('Error: test is being run on production'));
+ }
+
+ if (!await firestore.isStaging()) {
+ throw 'Test cannot be run on production database';
+ }
+ commitsCache = CommitsCache(firestore, mockClient);
+ setUpAll(addFakeResultsToLandedReviews);
+ tearDownAll(() async {
+ await deleteFakeReviewAndResults();
+ baseClient.close();
+ });
+
+ test('create fake review', () async {
+ registerChangeForDeletion(unchangedChange);
+ final tryjob = Tryjob('refs/changes/$fakeReview/2', buildBuildbucketId,
+ buildBaseCommitHash, commitsCache, firestore, mockClient);
+ await tryjob.process([unchangedChange]);
+ expect(tryjob.success, true);
+ });
+
+ test('failure coming from a landed CL not in base', () async {
+ registerChangeForDeletion(changeMatchingLandedCL);
+ final tryjob = Tryjob('refs/changes/$fakeReview/2', buildBuildbucketId,
+ buildBaseCommitHash, commitsCache, firestore, mockClient);
+ await tryjob.process([changeMatchingLandedCL]);
+ expect(tryjob.success, true);
+ });
+
+ // TODO(karlklose): These tests do not apply to the new model of processing a
+ // build in one step.
+
+ // test('process result on different configuration', () async {
+ // final changeOnDifferentConfiguration = Map<String, dynamic>.from(baseChange)
+ // ..['configuration'] = otherConfiguration;
+
+ // registerChangeForDeletion(changeOnDifferentConfiguration);
+ // final tryjob = Tryjob('refs/changes/$fakeReview/2', buildBuildbucketId,
+ // buildBaseCommitHash, commitsCache, firestore, mockClient);
+ // await tryjob.process([changeOnDifferentConfiguration]);
+ // expect(tryjob.success, false);
+ // });
+
+ // test('process result where different result landed last', () async {
+ // final otherNameChange = Map<String, dynamic>.from(baseChange)
+ // ..['name'] = otherFakeTest;
+ // registerChangeForDeletion(otherNameChange);
+ // final tryjob = Tryjob('refs/changes/$fakeReview/2', buildBuildbucketId,
+ // buildBaseCommitHash, commitsCache, firestore, mockClient);
+ // await tryjob.process([otherNameChange]);
+ // expect(tryjob.success, false);
+ // });
+
+ test('test becomes flaky', () async {
+ final flakyTest = <String, dynamic>{
+ 'name': 'flaky_test',
+ 'result': 'RuntimeError',
+ 'flaky': true,
+ 'matches': false,
+ 'changed': true,
+ 'build_number': '99995',
+ 'builder_name': 'flaky_test_builder-try',
+ };
+
+ final flakyChange = Map<String, dynamic>.from(baseChange)
+ ..addAll(flakyTest);
+ final flakyTestBuildbucketId = 'flaky_buildbucket_ID';
+ registerChangeForDeletion(flakyChange);
+ final tryjob = Tryjob('refs/changes/$fakeReview/2', flakyTestBuildbucketId,
+ buildBaseCommitHash, commitsCache, firestore, mockClient);
+ await tryjob.process([flakyChange]);
+ expect(tryjob.success, true);
+ expect(tryjob.countNewFlakes, 1);
+ expect(tryjob.countUnapproved, 0);
+ });
+
+ test('new failure', () async {
+ final failingTest = <String, dynamic>{
+ 'name': 'failing_test',
+ 'result': 'RuntimeError',
+ 'matches': false,
+ 'changed': true,
+ 'build_number': '99994',
+ 'builder_name': 'failing_test_builder-try',
+ };
+
+ final failingChange = Map<String, dynamic>.from(baseChange)
+ ..addAll(failingTest);
+ final failingTestBuildbucketId = 'failing_buildbucket_ID';
+ registerChangeForDeletion(failingChange);
+ final tryjob = Tryjob(
+ 'refs/changes/$fakeReview/2',
+ failingTestBuildbucketId,
+ buildBaseCommitHash,
+ commitsCache,
+ firestore,
+ mockClient);
+ await tryjob.process([failingChange]);
+ expect(tryjob.success, false);
+ expect(tryjob.countNewFlakes, 0);
+ expect(tryjob.countUnapproved, 1);
+ });
+}
+
+void addFakeReplies(HttpClientMock client) {
+ when(client.get(any))
+ .thenAnswer((_) => Future(() => ResponseFake(FakeReviewGerritLog)));
+}
+
+Future<void> addFakeResultsToLandedReviews() async {
+ var tryjob = Tryjob(matchingLandedChange['commit_hash'], buildBuildbucketId,
+ earlierTryBuildsBaseCommit, commitsCache, firestore, client);
+ await tryjob.process([matchingLandedChange, overriddenMatchingLandedChange]);
+ expect(tryjob.success, false);
+ tryjob = Tryjob(
+ overridingUnmatchingLandedChange['commit_hash'],
+ buildBuildbucketId,
+ earlierTryBuildsBaseCommit,
+ commitsCache,
+ firestore,
+ client);
+ await tryjob.process([overridingUnmatchingLandedChange]);
+ expect(tryjob.success, false);
+}
+
+Future<void> deleteFakeReviewAndResults() async {
+ Future<void> deleteDocuments(List<RunQueryResponse> response) async {
+ for (final document in response.map((r) => r.document)) {
+ await firestore.deleteDocument(document.name);
+ }
+ }
+
+ for (final test in fakeTests) {
+ await deleteDocuments(await firestore.query(
+ from: 'try_results', where: fieldEquals('name', test)));
+ }
+ for (final builder in fakeBuilders) {
+ await deleteDocuments(await firestore.query(
+ from: 'try_builds', where: fieldEquals('builder', builder)));
+ }
+
+ await firestore.deleteDocument(firestore.documents + '/reviews/$fakeReview');
+}
+
+Map<String, dynamic> baseChange = {
+ 'name': fakeTest,
+ 'configuration': fakeConfiguration,
+ 'suite': fakeSuite,
+ 'test_name': fakeTestName,
+ 'time_ms': 2384,
+ 'result': 'RuntimeError',
+ 'previous_result': 'Pass',
+ 'expected': 'Pass',
+ 'matches': false,
+ 'changed': true,
+ 'commit_hash': 'refs/changes/$fakeReview/2',
+ 'commit_time': 1583906489,
+ 'build_number': '99997',
+ 'builder_name': fakeBuilderName,
+ 'flaky': false,
+ 'previous_flaky': false,
+ 'previous_commit_hash': ciResultsCommitHash,
+ 'previous_commit_time': 1583906489,
+ 'bot_name': 'luci-dart-try-xenial-70-8fkh',
+ 'previous_build_number': '306',
+};
+
+Map<String, dynamic> changeMatchingLandedCL = Map.from(baseChange);
+
+Map<String, dynamic> unchangedChange = Map.from(baseChange)
+ ..addAll({
+ 'name': otherFakeTest,
+ 'test_name': otherFakeTestName,
+ 'result': 'Pass',
+ 'matches': true,
+ 'changed': false,
+ 'configuration': otherConfiguration,
+ 'build_number': '99997'
+ });
+
+Map<String, dynamic> matchingLandedChange = Map.from(baseChange)
+ ..addAll({
+ 'commit_hash': 'refs/changes/$reviewForCommit69190/$patchsetForCommit69190',
+ 'build_number': tryBuildForCommit69190,
+ 'previous_commit_hash': earlierTryBuildsResultsCommit,
+ });
+
+Map<String, dynamic> overriddenMatchingLandedChange =
+ Map.from(matchingLandedChange)
+ ..addAll({
+ 'name': otherFakeTest,
+ 'test_name': otherFakeTestName,
+ });
+
+Map<String, dynamic> overridingUnmatchingLandedChange =
+ Map.from(overriddenMatchingLandedChange)
+ ..addAll({
+ 'commit_hash':
+ 'refs/changes/$reviewForCommit69191/$patchsetForCommit69191',
+ 'result': 'CompileTimeError',
+ 'build_number': tryBuildForCommit69191,
+ });
+
+String FakeReviewGerritLog = '''
+)]}'
+{
+ "id": "sdk~master~Ie212fae88bc1977e34e4d791c644b77783a8deb1",
+ "project": "sdk",
+ "branch": "master",
+ "hashtags": [],
+ "change_id": "Ie212fae88bc1977e34e4d791c644b77783a8deb1",
+ "subject": "A fake review",
+ "status": "MERGED",
+ "created": "2020-03-17 12:17:05.000000000",
+ "updated": "2020-03-17 12:17:25.000000000",
+ "submitted": "2020-03-17 12:17:25.000000000",
+ "submitter": {
+ "_account_id": 5260,
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org"
+ },
+ "insertions": 61,
+ "deletions": 155,
+ "total_comment_count": 0,
+ "unresolved_comment_count": 0,
+ "has_review_started": true,
+ "submission_id": "$fakeReview",
+ "_number": $fakeReview,
+ "owner": {
+ },
+ "current_revision": "82f3f81fc82d06c575b0137ddbe71408826d8b46",
+ "revisions": {
+ "82f3f81fc82d06c575b0137ddbe71408826d8b46": {
+ "kind": "REWORK",
+ "_number": 2,
+ "created": "2020-02-17 12:17:25.000000000",
+ "uploader": {
+ "_account_id": 5260,
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org"
+ },
+ "ref": "refs/changes/23/$fakeReview/2",
+ "fetch": {
+ "rpc": {
+ "url": "rpc://dart/sdk",
+ "ref": "refs/changes/23/$fakeReview/2"
+ },
+ "http": {
+ "url": "https://dart.googlesource.com/sdk",
+ "ref": "refs/changes/23/$fakeReview/2"
+ },
+ "sso": {
+ "url": "sso://dart/sdk",
+ "ref": "refs/changes/23/$fakeReview/2"
+ }
+ },
+ "commit": {
+ "parents": [
+ {
+ "commit": "d2d00ff357bd64a002697b3c96c92a0fec83328c",
+ "subject": "[cfe] Allow unassigned late local variables"
+ }
+ ],
+ "author": {
+ "name": "gerrit_user",
+ "email": "gerrit_user@example.com",
+ "date": "2020-02-17 12:17:25.000000000",
+ "tz": 0
+ },
+ "committer": {
+ "name": "commit-bot@chromium.org",
+ "email": "commit-bot@chromium.org",
+ "date": "2020-02-17 12:17:25.000000000",
+ "tz": 0
+ },
+ "subject": "A fake review",
+ "message": "A fake review\\n\\nReviewed-by: XXX\\nCommit-Queue: XXXXXX\\n"
+ },
+ "description": "Rebase"
+ },
+ "8bae95c4001a0815e89ebc4c89dc5ad42337a01b": {
+ "kind": "REWORK",
+ "_number": 1,
+ "created": "2020-02-17 12:17:05.000000000",
+ "uploader": {
+ },
+ "ref": "refs/changes/23/$fakeReview/1",
+ "fetch": {
+ "rpc": {
+ "url": "rpc://dart/sdk",
+ "ref": "refs/changes/23/$fakeReview/1"
+ },
+ "http": {
+ "url": "https://dart.googlesource.com/sdk",
+ "ref": "refs/changes/23/$fakeReview/1"
+ },
+ "sso": {
+ "url": "sso://dart/sdk",
+ "ref": "refs/changes/23/$fakeReview/1"
+ }
+ }
+ }
+ },
+ "requirements": []
+}
+''';
