app_dart/test/request_handlers/postsubmit_luci_subscription_v2_test.dart - mirrors/cocoon - Git at Google

 // Copyright 2019 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import 'package:buildbucket/buildbucket_pb.dart' as bbv2;
 import 'package:cocoon_service/cocoon_service.dart';
 import 'package:cocoon_service/src/model/appengine/commit.dart';
 import 'package:cocoon_service/src/model/appengine/task.dart';
 import 'package:cocoon_service/src/model/firestore/commit.dart' as firestore_commit;
 import 'package:cocoon_service/src/model/firestore/task.dart' as firestore;
 import 'package:cocoon_service/src/request_handlers/postsubmit_luci_subscription_v2.dart';
 import 'package:cocoon_service/src/request_handling/exceptions.dart';
 import 'package:cocoon_service/src/service/datastore.dart';
 import 'package:googleapis/firestore/v1.dart';
 import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';

 import '../src/datastore/fake_config.dart';
 import '../src/request_handling/fake_authentication.dart';
 import '../src/request_handling/fake_http.dart';
 import '../src/request_handling/subscription_v2_tester.dart';
 import '../src/service/fake_luci_build_service_v2.dart';
 import '../src/service/fake_scheduler_v2.dart';
 import '../src/utilities/build_bucket_v2_messages.dart';
 import '../src/utilities/entity_generators.dart';
 import '../src/utilities/mocks.dart';
 import 'package:fixnum/fixnum.dart';

 void main() {
   late PostsubmitLuciSubscriptionV2 handler;
   late FakeConfig config;
   late FakeHttpRequest request;
   late MockFirestoreService mockFirestoreService;
   late SubscriptionV2Tester tester;
   late MockGithubChecksServiceV2 mockGithubChecksService;
   late MockGithubChecksUtil mockGithubChecksUtil;
   late FakeSchedulerV2 scheduler;
   firestore.Task? firestoreTask;
   firestore_commit.Commit? firestoreCommit;
   late int attempt;

   setUp(() async {
     firestoreTask = null;
     attempt = 0;
     mockGithubChecksUtil = MockGithubChecksUtil();
     mockFirestoreService = MockFirestoreService();
     config = FakeConfig(
       maxLuciTaskRetriesValue: 3,
       firestoreService: mockFirestoreService,
     );
     mockGithubChecksService = MockGithubChecksServiceV2();
     when(mockGithubChecksService.githubChecksUtil).thenReturn(mockGithubChecksUtil);
     when(mockGithubChecksUtil.createCheckRun(any, any, any, any, output: anyNamed('output')))
         .thenAnswer((_) async => generateCheckRun(1, name: 'Linux A'));
     when(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     ).thenAnswer((_) async => true);
     when(
       mockFirestoreService.getDocument(
         captureAny,
       ),
     ).thenAnswer((Invocation invocation) {
       attempt++;
       if (attempt == 1) {
         return Future<Document>.value(
           firestoreTask,
         );
       } else {
         return Future<Document>.value(
           firestoreCommit,
         );
       }
     });
     when(
       mockFirestoreService.queryRecentCommits(
         limit: captureAnyNamed('limit'),
         slug: captureAnyNamed('slug'),
         branch: captureAnyNamed('branch'),
       ),
     ).thenAnswer((Invocation invocation) {
       return Future<List<firestore_commit.Commit>>.value(
         <firestore_commit.Commit>[firestoreCommit!],
       );
     });
     // when(
     //   mockFirestoreService.getDocument(
     //     'projects/flutter-dashboard/databases/cocoon/documents/tasks/87f88734747805589f2131753620d61b22922822_Linux A_1',
     //   ),
     // ).thenAnswer((Invocation invocation) {
     //   return Future<Document>.value(
     //     firestoreCommit,
     //   );
     // });
     when(
       mockFirestoreService.batchWriteDocuments(
         captureAny,
         captureAny,
       ),
     ).thenAnswer((Invocation invocation) {
       return Future<BatchWriteResponse>.value(BatchWriteResponse());
     });
     final FakeLuciBuildServiceV2 luciBuildService = FakeLuciBuildServiceV2(
       config: config,
       githubChecksUtil: mockGithubChecksUtil,
     );
     scheduler = FakeSchedulerV2(
       ciYaml: exampleConfig,
       config: config,
       luciBuildService: luciBuildService,
     );
     handler = PostsubmitLuciSubscriptionV2(
       cache: CacheService(inMemory: true),
       config: config,
       authProvider: FakeAuthenticationProvider(),
       githubChecksService: mockGithubChecksService,
       datastoreProvider: (_) => DatastoreService(config.db, 5),
       scheduler: scheduler,
     );
     request = FakeHttpRequest();

     tester = SubscriptionV2Tester(
       request: request,
     );
   });

   test('throws exception when task document name is not in message', () async {
     const Map<String, dynamic> userDataMap = {
       'commit_key': 'flutter/main/abc123',
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       builder: '',
       userData: userDataMap,
     );

     expect(() => tester.post(handler), throwsA(isA<BadRequestException>()));
   });

   test('updates task based on message', () async {
     firestoreTask = generateFirestoreTask(1, attempts: 2, name: 'Linux A');
     when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
     );
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       userData: userDataMap,
     );

     config.db.values[commit.key] = commit;
     config.db.values[task.key] = task;

     expect(task.status, Task.statusNew);
     expect(task.endTimestamp, 0);

     // Firestore checks before API call.
     expect(firestoreTask!.status, Task.statusNew);
     expect(firestoreTask!.buildNumber, null);

     await tester.post(handler);

     expect(task.status, Task.statusSucceeded);
     expect(task.endTimestamp, 1697672824674);

     // Firestore checks after API call.
     final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
     expect(captured.length, 2);
     final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
     expect(batchWriteRequest.writes!.length, 1);
     final Document updatedDocument = batchWriteRequest.writes![0].update!;
     expect(updatedDocument.name, firestoreTask!.name);
     expect(firestoreTask!.status, Task.statusSucceeded);
     expect(firestoreTask!.buildNumber, 259942);
   });

   test('skips task processing when build is with scheduled status', () async {
     firestoreTask = generateFirestoreTask(1, name: 'Linux A', status: firestore.Task.statusInProgress);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
       status: Task.statusInProgress,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SCHEDULED,
       builder: 'Linux A',
       userData: userDataMap,
     );

     expect(firestoreTask!.status, firestore.Task.statusInProgress);
     expect(firestoreTask!.attempts, 1);
     expect(await tester.post(handler), Body.empty);
     expect(firestoreTask!.status, firestore.Task.statusInProgress);
   });

   test('skips task processing when task has already finished', () async {
     firestoreTask = generateFirestoreTask(1, name: 'Linux A', status: firestore.Task.statusSucceeded);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
       status: Task.statusSucceeded,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.STARTED,
       builder: 'Linux A',
       userData: userDataMap,
     );

     expect(task.status, Task.statusSucceeded);
     expect(task.attempts, 1);
     expect(await tester.post(handler), Body.empty);
     expect(task.status, Task.statusSucceeded);
   });

   test('skips task processing when target has been deleted', () async {
     firestoreTask = generateFirestoreTask(1, name: 'Linux B', status: firestore.Task.statusSucceeded);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux B',
       parent: commit,
       status: Task.statusSucceeded,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.STARTED,
       builder: 'Linux B',
       userData: userDataMap,
     );

     expect(task.status, Task.statusSucceeded);
     expect(task.attempts, 1);
     expect(await tester.post(handler), Body.empty);
   });

   test('does not fail on empty user data', () async {
     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       builder: 'Linux A',
     );
     expect(await tester.post(handler), Body.empty);
   });

   test('on failed builds auto-rerun the build', () async {
     firestoreTask = generateFirestoreTask(
       1,
       name: 'Linux A',
       status: firestore.Task.statusFailed,
       commitSha: '87f88734747805589f2131753620d61b22922822',
     );
     firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
       status: Task.statusFailed,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.FAILURE,
       builder: 'Linux A',
       userData: userDataMap,
     );

     expect(firestoreTask!.status, firestore.Task.statusFailed);
     expect(firestoreTask!.attempts, 1);
     expect(await tester.post(handler), Body.empty);
     final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
     expect(captured.length, 2);
     final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
     expect(batchWriteRequest.writes!.length, 1);
     final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
     final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
     expect(resultTask.status, firestore.Task.statusInProgress);
     expect(resultTask.attempts, 2);
   });

   test('on canceled builds auto-rerun the build if they timed out', () async {
     firestoreTask = generateFirestoreTask(
       1,
       name: 'Linux A',
       status: firestore.Task.statusInfraFailure,
       commitSha: '87f88734747805589f2131753620d61b22922822',
     );
     firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
       status: Task.statusInfraFailure,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.CANCELED,
       builder: 'Linux A',
       userData: userDataMap,
     );

     expect(firestoreTask!.status, firestore.Task.statusInfraFailure);
     expect(firestoreTask!.attempts, 1);
     expect(await tester.post(handler), Body.empty);
     final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
     expect(captured.length, 2);
     final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
     expect(batchWriteRequest.writes!.length, 1);
     final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
     final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
     expect(resultTask.status, firestore.Task.statusInProgress);
     expect(resultTask.attempts, 2);
   });

   test('on builds resulting in an infra failure auto-rerun the build if they timed out', () async {
     firestoreTask = generateFirestoreTask(
       1,
       name: 'Linux A',
       status: firestore.Task.statusInfraFailure,
       commitSha: '87f88734747805589f2131753620d61b22922822',
     );
     firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux A',
       parent: commit,
       status: Task.statusInfraFailure,
     );
     config.db.values[task.key] = task;
     config.db.values[commit.key] = commit;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.INFRA_FAILURE,
       builder: 'Linux A',
       userData: userDataMap,
     );

     expect(task.status, Task.statusInfraFailure);
     expect(task.attempts, 1);
     expect(await tester.post(handler), Body.empty);
     final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
     expect(captured.length, 2);
     final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
     expect(batchWriteRequest.writes!.length, 1);
     final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
     final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
     expect(resultTask.status, firestore.Task.statusInProgress);
     expect(resultTask.attempts, 2);
   });

   test('non-bringup target updates check run', () async {
     firestoreTask = generateFirestoreTask(1, name: 'Linux nonbringup');
     scheduler.ciYaml = nonBringupPackagesConfig;
     when(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     ).thenAnswer((_) async => true);
     when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822', repo: 'packages');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux nonbringup',
       parent: commit,
     );
     config.db.values[commit.key] = commit;
     config.db.values[task.key] = task;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       builder: 'Linux A',
       userData: userDataMap,
     );

     await tester.post(handler);
     verify(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     ).called(1);
   });

   test('bringup target does not update check run', () async {
     firestoreTask = generateFirestoreTask(1, name: 'Linux bringup');
     scheduler.ciYaml = bringupPackagesConfig;
     when(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     ).thenAnswer((_) async => true);
     when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux bringup',
       parent: commit,
     );
     config.db.values[commit.key] = commit;
     config.db.values[task.key] = task;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       builder: 'Linux bringup',
       userData: userDataMap,
     );

     await tester.post(handler);
     verifyNever(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     );
   });

   test('unsupported repo target does not update check run', () async {
     scheduler.ciYaml = unsupportedPostsubmitCheckrunConfig;
     when(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     ).thenAnswer((_) async => true);
     when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
     firestoreTask = generateFirestoreTask(1, attempts: 2, name: 'Linux flutter');

     final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
     final Task task = generateTask(
       4507531199512576,
       name: 'Linux flutter',
       parent: commit,
     );
     config.db.values[commit.key] = commit;
     config.db.values[task.key] = task;
     final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

     final Map<String, dynamic> userDataMap = {
       'task_key': '${task.key.id}',
       'commit_key': '${task.key.parent?.id}',
       'firestore_commit_document_name': commit.sha,
       'firestore_task_document_name': taskDocumentName,
     };

     tester.message = createPushMessageV2(
       Int64(1),
       status: bbv2.Status.SUCCESS,
       builder: 'Linux bringup',
       userData: userDataMap,
     );

     await tester.post(handler);
     verifyNever(
       mockGithubChecksService.updateCheckStatus(
         build: anyNamed('build'),
         userDataMap: anyNamed('userDataMap'),
         luciBuildService: anyNamed('luciBuildService'),
         slug: anyNamed('slug'),
       ),
     );
   });
 }
	// Copyright 2019 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import 'package:buildbucket/buildbucket_pb.dart' as bbv2;
	import 'package:cocoon_service/cocoon_service.dart';
	import 'package:cocoon_service/src/model/appengine/commit.dart';
	import 'package:cocoon_service/src/model/appengine/task.dart';
	import 'package:cocoon_service/src/model/firestore/commit.dart' as firestore_commit;
	import 'package:cocoon_service/src/model/firestore/task.dart' as firestore;
	import 'package:cocoon_service/src/request_handlers/postsubmit_luci_subscription_v2.dart';
	import 'package:cocoon_service/src/request_handling/exceptions.dart';
	import 'package:cocoon_service/src/service/datastore.dart';
	import 'package:googleapis/firestore/v1.dart';
	import 'package:mockito/mockito.dart';
	import 'package:test/test.dart';

	import '../src/datastore/fake_config.dart';
	import '../src/request_handling/fake_authentication.dart';
	import '../src/request_handling/fake_http.dart';
	import '../src/request_handling/subscription_v2_tester.dart';
	import '../src/service/fake_luci_build_service_v2.dart';
	import '../src/service/fake_scheduler_v2.dart';
	import '../src/utilities/build_bucket_v2_messages.dart';
	import '../src/utilities/entity_generators.dart';
	import '../src/utilities/mocks.dart';
	import 'package:fixnum/fixnum.dart';

	void main() {
	late PostsubmitLuciSubscriptionV2 handler;
	late FakeConfig config;
	late FakeHttpRequest request;
	late MockFirestoreService mockFirestoreService;
	late SubscriptionV2Tester tester;
	late MockGithubChecksServiceV2 mockGithubChecksService;
	late MockGithubChecksUtil mockGithubChecksUtil;
	late FakeSchedulerV2 scheduler;
	firestore.Task? firestoreTask;
	firestore_commit.Commit? firestoreCommit;
	late int attempt;

	setUp(() async {
	firestoreTask = null;
	attempt = 0;
	mockGithubChecksUtil = MockGithubChecksUtil();
	mockFirestoreService = MockFirestoreService();
	config = FakeConfig(
	maxLuciTaskRetriesValue: 3,
	firestoreService: mockFirestoreService,
	);
	mockGithubChecksService = MockGithubChecksServiceV2();
	when(mockGithubChecksService.githubChecksUtil).thenReturn(mockGithubChecksUtil);
	when(mockGithubChecksUtil.createCheckRun(any, any, any, any, output: anyNamed('output')))
	.thenAnswer((_) async => generateCheckRun(1, name: 'Linux A'));
	when(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	).thenAnswer((_) async => true);
	when(
	mockFirestoreService.getDocument(
	captureAny,
	),
	).thenAnswer((Invocation invocation) {
	attempt++;
	if (attempt == 1) {
	return Future<Document>.value(
	firestoreTask,
	);
	} else {
	return Future<Document>.value(
	firestoreCommit,
	);
	}
	});
	when(
	mockFirestoreService.queryRecentCommits(
	limit: captureAnyNamed('limit'),
	slug: captureAnyNamed('slug'),
	branch: captureAnyNamed('branch'),
	),
	).thenAnswer((Invocation invocation) {
	return Future<List<firestore_commit.Commit>>.value(
	<firestore_commit.Commit>[firestoreCommit!],
	);
	});
	// when(
	// mockFirestoreService.getDocument(
	// 'projects/flutter-dashboard/databases/cocoon/documents/tasks/87f88734747805589f2131753620d61b22922822_Linux A_1',
	// ),
	// ).thenAnswer((Invocation invocation) {
	// return Future<Document>.value(
	// firestoreCommit,
	// );
	// });
	when(
	mockFirestoreService.batchWriteDocuments(
	captureAny,
	captureAny,
	),
	).thenAnswer((Invocation invocation) {
	return Future<BatchWriteResponse>.value(BatchWriteResponse());
	});
	final FakeLuciBuildServiceV2 luciBuildService = FakeLuciBuildServiceV2(
	config: config,
	githubChecksUtil: mockGithubChecksUtil,
	);
	scheduler = FakeSchedulerV2(
	ciYaml: exampleConfig,
	config: config,
	luciBuildService: luciBuildService,
	);
	handler = PostsubmitLuciSubscriptionV2(
	cache: CacheService(inMemory: true),
	config: config,
	authProvider: FakeAuthenticationProvider(),
	githubChecksService: mockGithubChecksService,
	datastoreProvider: (_) => DatastoreService(config.db, 5),
	scheduler: scheduler,
	);
	request = FakeHttpRequest();

	tester = SubscriptionV2Tester(
	request: request,
	);
	});

	test('throws exception when task document name is not in message', () async {
	const Map<String, dynamic> userDataMap = {
	'commit_key': 'flutter/main/abc123',
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	builder: '',
	userData: userDataMap,
	);

	expect(() => tester.post(handler), throwsA(isA<BadRequestException>()));
	});

	test('updates task based on message', () async {
	firestoreTask = generateFirestoreTask(1, attempts: 2, name: 'Linux A');
	when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	);
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	userData: userDataMap,
	);

	config.db.values[commit.key] = commit;
	config.db.values[task.key] = task;

	expect(task.status, Task.statusNew);
	expect(task.endTimestamp, 0);

	// Firestore checks before API call.
	expect(firestoreTask!.status, Task.statusNew);
	expect(firestoreTask!.buildNumber, null);

	await tester.post(handler);

	expect(task.status, Task.statusSucceeded);
	expect(task.endTimestamp, 1697672824674);

	// Firestore checks after API call.
	final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
	expect(captured.length, 2);
	final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
	expect(batchWriteRequest.writes!.length, 1);
	final Document updatedDocument = batchWriteRequest.writes![0].update!;
	expect(updatedDocument.name, firestoreTask!.name);
	expect(firestoreTask!.status, Task.statusSucceeded);
	expect(firestoreTask!.buildNumber, 259942);
	});

	test('skips task processing when build is with scheduled status', () async {
	firestoreTask = generateFirestoreTask(1, name: 'Linux A', status: firestore.Task.statusInProgress);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	status: Task.statusInProgress,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SCHEDULED,
	builder: 'Linux A',
	userData: userDataMap,
	);

	expect(firestoreTask!.status, firestore.Task.statusInProgress);
	expect(firestoreTask!.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	expect(firestoreTask!.status, firestore.Task.statusInProgress);
	});

	test('skips task processing when task has already finished', () async {
	firestoreTask = generateFirestoreTask(1, name: 'Linux A', status: firestore.Task.statusSucceeded);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	status: Task.statusSucceeded,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.STARTED,
	builder: 'Linux A',
	userData: userDataMap,
	);

	expect(task.status, Task.statusSucceeded);
	expect(task.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	expect(task.status, Task.statusSucceeded);
	});

	test('skips task processing when target has been deleted', () async {
	firestoreTask = generateFirestoreTask(1, name: 'Linux B', status: firestore.Task.statusSucceeded);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux B',
	parent: commit,
	status: Task.statusSucceeded,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.STARTED,
	builder: 'Linux B',
	userData: userDataMap,
	);

	expect(task.status, Task.statusSucceeded);
	expect(task.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	});

	test('does not fail on empty user data', () async {
	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	builder: 'Linux A',
	);
	expect(await tester.post(handler), Body.empty);
	});

	test('on failed builds auto-rerun the build', () async {
	firestoreTask = generateFirestoreTask(
	1,
	name: 'Linux A',
	status: firestore.Task.statusFailed,
	commitSha: '87f88734747805589f2131753620d61b22922822',
	);
	firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	status: Task.statusFailed,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.FAILURE,
	builder: 'Linux A',
	userData: userDataMap,
	);

	expect(firestoreTask!.status, firestore.Task.statusFailed);
	expect(firestoreTask!.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
	expect(captured.length, 2);
	final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
	expect(batchWriteRequest.writes!.length, 1);
	final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
	final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
	expect(resultTask.status, firestore.Task.statusInProgress);
	expect(resultTask.attempts, 2);
	});

	test('on canceled builds auto-rerun the build if they timed out', () async {
	firestoreTask = generateFirestoreTask(
	1,
	name: 'Linux A',
	status: firestore.Task.statusInfraFailure,
	commitSha: '87f88734747805589f2131753620d61b22922822',
	);
	firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	status: Task.statusInfraFailure,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.CANCELED,
	builder: 'Linux A',
	userData: userDataMap,
	);

	expect(firestoreTask!.status, firestore.Task.statusInfraFailure);
	expect(firestoreTask!.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
	expect(captured.length, 2);
	final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
	expect(batchWriteRequest.writes!.length, 1);
	final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
	final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
	expect(resultTask.status, firestore.Task.statusInProgress);
	expect(resultTask.attempts, 2);
	});

	test('on builds resulting in an infra failure auto-rerun the build if they timed out', () async {
	firestoreTask = generateFirestoreTask(
	1,
	name: 'Linux A',
	status: firestore.Task.statusInfraFailure,
	commitSha: '87f88734747805589f2131753620d61b22922822',
	);
	firestoreCommit = generateFirestoreCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux A',
	parent: commit,
	status: Task.statusInfraFailure,
	);
	config.db.values[task.key] = task;
	config.db.values[commit.key] = commit;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.INFRA_FAILURE,
	builder: 'Linux A',
	userData: userDataMap,
	);

	expect(task.status, Task.statusInfraFailure);
	expect(task.attempts, 1);
	expect(await tester.post(handler), Body.empty);
	final List<dynamic> captured = verify(mockFirestoreService.batchWriteDocuments(captureAny, captureAny)).captured;
	expect(captured.length, 2);
	final BatchWriteRequest batchWriteRequest = captured[0] as BatchWriteRequest;
	expect(batchWriteRequest.writes!.length, 1);
	final Document insertedTaskDocument = batchWriteRequest.writes![0].update!;
	final firestore.Task resultTask = firestore.Task.fromDocument(taskDocument: insertedTaskDocument);
	expect(resultTask.status, firestore.Task.statusInProgress);
	expect(resultTask.attempts, 2);
	});

	test('non-bringup target updates check run', () async {
	firestoreTask = generateFirestoreTask(1, name: 'Linux nonbringup');
	scheduler.ciYaml = nonBringupPackagesConfig;
	when(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	).thenAnswer((_) async => true);
	when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822', repo: 'packages');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux nonbringup',
	parent: commit,
	);
	config.db.values[commit.key] = commit;
	config.db.values[task.key] = task;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	builder: 'Linux A',
	userData: userDataMap,
	);

	await tester.post(handler);
	verify(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	).called(1);
	});

	test('bringup target does not update check run', () async {
	firestoreTask = generateFirestoreTask(1, name: 'Linux bringup');
	scheduler.ciYaml = bringupPackagesConfig;
	when(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	).thenAnswer((_) async => true);
	when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux bringup',
	parent: commit,
	);
	config.db.values[commit.key] = commit;
	config.db.values[task.key] = task;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	builder: 'Linux bringup',
	userData: userDataMap,
	);

	await tester.post(handler);
	verifyNever(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	);
	});

	test('unsupported repo target does not update check run', () async {
	scheduler.ciYaml = unsupportedPostsubmitCheckrunConfig;
	when(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	).thenAnswer((_) async => true);
	when(mockGithubChecksService.currentAttempt(any)).thenAnswer((_) => 2);
	firestoreTask = generateFirestoreTask(1, attempts: 2, name: 'Linux flutter');

	final Commit commit = generateCommit(1, sha: '87f88734747805589f2131753620d61b22922822');
	final Task task = generateTask(
	4507531199512576,
	name: 'Linux flutter',
	parent: commit,
	);
	config.db.values[commit.key] = commit;
	config.db.values[task.key] = task;
	final String taskDocumentName = '${commit.sha}_${task.name}_${task.attempts}';

	final Map<String, dynamic> userDataMap = {
	'task_key': '${task.key.id}',
	'commit_key': '${task.key.parent?.id}',
	'firestore_commit_document_name': commit.sha,
	'firestore_task_document_name': taskDocumentName,
	};

	tester.message = createPushMessageV2(
	Int64(1),
	status: bbv2.Status.SUCCESS,
	builder: 'Linux bringup',
	userData: userDataMap,
	);

	await tester.post(handler);
	verifyNever(
	mockGithubChecksService.updateCheckStatus(
	build: anyNamed('build'),
	userDataMap: anyNamed('userDataMap'),
	luciBuildService: anyNamed('luciBuildService'),
	slug: anyNamed('slug'),
	),
	);
	});
	}