Make AnalysisServer.onAnalysisComplete a Future and wait for it before refactoring.

pkg/analysis_server/test/domain_analysis_test.dart

 // Copyright (c) 2014, 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.
 
 library test.domain.analysis;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 50 matching lines @@
         test('excluded folder', () {
           String fileA = '/project/aaa/a.dart';
           String fileB = '/project/bbb/b.dart';
           resourceProvider.newFile(fileA, '// a');
           resourceProvider.newFile(fileB, '// b');
           var response = testSetAnalysisRoots(['/project'], ['/project/bbb']);
           var serverRef = server;
           expect(response, isResponseSuccess('0'));
           // unit "a" is resolved eventually
           // unit "b" is not resolved
-          return waitForServerOperationsPerformed(server).then((_) {
+          return server.onAnalysisComplete.then((_) {
             expect(serverRef.getResolvedCompilationUnits(fileA), hasLength(1));
             expect(serverRef.getResolvedCompilationUnits(fileB), isEmpty);
           });
         });
       });
 
       group('included', () {
         test('new folder', () {
           String file = '/project/bin/test.dart';
           resourceProvider.newFile('/project/pubspec.yaml', 'name: project');
           resourceProvider.newFile(file, 'main() {}');
           var response = testSetAnalysisRoots(['/project'], []);
           var serverRef = server;
           expect(response, isResponseSuccess('0'));
           // verify that unit is resolved eventually
-          return waitForServerOperationsPerformed(server).then((_) {
+          return server.onAnalysisComplete.then((_) {
             var units = serverRef.getResolvedCompilationUnits(file);
             expect(units, hasLength(1));
           });
         });
       });
     });
 
     group('setPriorityFiles', () {
       test('invalid', () {
         // TODO(paulberry): under the "eventual consistency" model this request
@@ skipping 58 matching lines @@
 
 
 void test_setSubscriptions() {
   test('before analysis', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     // subscribe
     helper.addAnalysisSubscriptionHighlights(helper.testFile);
     // create project
     helper.createSingleFileProject('int V = 42;');
     // wait, there are highlight regions
-    helper.waitForOperationsFinished().then((_) {
+    helper.onAnalysisComplete.then((_) {
       var highlights = helper.getHighlights(helper.testFile);
       expect(highlights, isNotEmpty);
     });
   });
 
   test('after analysis', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     // create project
     helper.createSingleFileProject('int V = 42;');
     // wait, no regions initially
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       var highlights = helper.getHighlights(helper.testFile);
       expect(highlights, isEmpty);
       // subscribe
       helper.addAnalysisSubscriptionHighlights(helper.testFile);
       // wait, has regions
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         var highlights = helper.getHighlights(helper.testFile);
         expect(highlights, isNotEmpty);
       });
     });
   });
 
   test('after analysis, no such file', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('int V = 42;');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       String noFile = '/no-such-file.dart';
       helper.addAnalysisSubscriptionHighlights(noFile);
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         var highlights = helper.getHighlights(noFile);
         expect(highlights, isEmpty);
       });
     });
   });
 
   test('after analysis, SDK file', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('''
 main() {
   print(42);
 }
 ''');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       String file = '/lib/core/core.dart';
       helper.addAnalysisSubscriptionNavigation(file);
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         var navigationRegions = helper.getNavigation(file);
         expect(navigationRegions, isNotEmpty);
       });
     });
   });
 }
 
 
 testUpdateContent() {
   test('bad type', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('// empty');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       Request request = new Request('0', ANALYSIS_UPDATE_CONTENT, {
         'files': {
           helper.testFile: {
             TYPE: 'foo',
           }
         }
       });
       Response response = helper.handler.handleRequest(request);
       expect(response, isResponseFailure('0'));
     });
   });
 
   test('full content', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('// empty');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       // no errors initially
       List<AnalysisError> errors = helper.getTestErrors();
       expect(errors, isEmpty);
       // update code
       helper.sendContentChange(new AddContentOverlay('library lib'));
       // wait, there is an error
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         List<AnalysisError> errors = helper.getTestErrors();
         expect(errors, hasLength(1));
       });
     });
   });
 
   test('incremental', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     String initialContent = 'library A;';
     helper.createSingleFileProject(initialContent);
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       // no errors initially
       List<AnalysisError> errors = helper.getTestErrors();
       expect(errors, isEmpty);
       // Add the file to the cache
       helper.sendContentChange(new AddContentOverlay(initialContent));
       // update code
       helper.sendContentChange(
           new ChangeContentOverlay(
               [new SourceEdit('library '.length, 'A;'.length, 'lib')]));
       // wait, there is an error
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         List<AnalysisError> errors = helper.getTestErrors();
         expect(errors, hasLength(1));
       });
     });
   });
 
   test('change on disk, normal', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('library A;');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       // There should be no errors
       expect(helper.getTestErrors(), hasLength(0));
       // Change file on disk, adding a syntax error.
       helper.resourceProvider.modifyFile(helper.testFile, 'library lib');
       // There should be errors now.
       return pumpEventQueue().then((_) {
-        return helper.waitForOperationsFinished().then((_) {
+        return helper.onAnalysisComplete.then((_) {
           expect(helper.getTestErrors(), hasLength(1));
         });
       });
     });
   });
 
   test('change on disk, during override', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('library A;');
-    return helper.waitForOperationsFinished().then((_) {
+    return helper.onAnalysisComplete.then((_) {
       // update code
       helper.sendContentChange(new AddContentOverlay('library B;'));
       // There should be no errors
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         expect(helper.getTestErrors(), hasLength(0));
         // Change file on disk, adding a syntax error.
         helper.resourceProvider.modifyFile(helper.testFile, 'library lib');
         // There should still be no errors (file should not have been reread).
-        return helper.waitForOperationsFinished().then((_) {
+        return helper.onAnalysisComplete.then((_) {
           expect(helper.getTestErrors(), hasLength(0));
           // Send a content change with a null content param--file should be
           // reread from disk.
           helper.sendContentChange(new RemoveContentOverlay());
           // There should be errors now.
-          return helper.waitForOperationsFinished().then((_) {
+          return helper.onAnalysisComplete.then((_) {
             expect(helper.getTestErrors(), hasLength(1));
           });
         });
       });
     });
   });
 
   group('out of range', () {
     Future outOfRangeTest(SourceEdit edit) {
       AnalysisTestHelper helper = new AnalysisTestHelper();
       helper.createSingleFileProject('library A;');
-      return helper.waitForOperationsFinished().then((_) {
+      return helper.onAnalysisComplete.then((_) {
         helper.sendContentChange(new AddContentOverlay('library B;'));
-        return helper.waitForOperationsFinished().then((_) {
+        return helper.onAnalysisComplete.then((_) {
           ChangeContentOverlay contentChange = new ChangeContentOverlay([edit]);
           Request request = new AnalysisUpdateContentParams({
             helper.testFile: contentChange
           }).toRequest('0');
           Response response = helper.handler.handleRequest(request);
           expect(
               response,
               isResponseFailure('0', RequestErrorCode.INVALID_OVERLAY_CHANGE));
         });
       });
@@ skipping 128 matching lines @@
         filesHighlights[params.file] = params.regions;
       }
       if (notification.event == ANALYSIS_NAVIGATION) {
         var params =
             new AnalysisNavigationParams.fromNotification(notification);
         filesNavigation[params.file] = params.regions;
       }
     });
   }
 
+  /**
+   * Returns a [Future] that completes when the server's analysis is complete.
+   */
+  Future get onAnalysisComplete {
+    return server.onAnalysisComplete;
+  }
+
   void addAnalysisSubscription(AnalysisService service, String file) {
     // add file to subscription
     var files = analysisSubscriptions[service];
     if (files == null) {
       files = <String>[];
       analysisSubscriptions[service] = files;
     }
     files.add(file);
     // set subscriptions
     Request request =
@@ skipping 125 matching lines @@
     return path;
   }
 
   /**
    * Stops the associated server.
    */
   void stopServer() {
     server.done();
   }
 
-  /**
-   * Returns a [Future] that completes when this this helper finished all its
-   * scheduled tasks.
-   */
-  Future waitForOperationsFinished() {
-    return waitForServerOperationsPerformed(server);
-  }
-
   static String _getCodeString(code) {
     if (code is List<String>) {
       code = code.join('\n');
     }
     return code as String;
   }
 }