Send responses for any pending 'analysis.getErrors' requests during context removal.

pkg/analysis_server/test/analysis/get_errors_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.analysis.get_errors;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/computer/error.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_services/constants.dart';
 import 'package:analysis_testing/reflective_tests.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:unittest/unittest.dart';
 
 import '../analysis_abstract.dart';
 
 
 main() {
-  group('notification.hover', () {
+  group('getErrors', () {
     runReflectiveTests(GetErrorsTest);
   });
 }
 
 
 @ReflectiveTestCase()
 class GetErrorsTest extends AbstractAnalysisTest {
-  Future<List<AnalysisError>> getErrors() {
-    return getErrorsForFile(testFile);
-  }
-
-  Future<List<AnalysisError>> getErrorsForFile(String file) {
-    return waitForTasksFinished().then((_) {
-      String requestId = 'test-getError';
-      // send the Request
-      Request request = new Request(requestId, ANALYSIS_GET_ERRORS);
-      request.setParameter(FILE, file);
-      server.handleRequest(request);
-      // wait for the Response
-      waitForResponse() {
-        for (Response response in serverChannel.responsesReceived) {
-          if (response.id == requestId) {
-            List errorsJsons = response.getResult(ERRORS);
-            return errorsJsons.map(AnalysisError.fromJson).toList();
-          }
-        }
-        return new Future(waitForResponse);
-      }
-      return new Future(waitForResponse);
-    });
-  }
+  static const String requestId = 'test-getError';
 
   @override
   void setUp() {
     super.setUp();
     server.handlers = [new AnalysisDomainHandler(server),];
     createProject();
   }
 
+  test_fileDoesNotExist() {
+    String file = '$projectPath/doesNotExist.dart';
+    return _getErrorsForFile(file).then((List<AnalysisError> errors) {
+      expect(errors, isEmpty);
+    });
+  }
+
+  test_fileWithoutContext() {
+    String file = '/outside.dart';
+    addFile(file, '''
+main() {
+  print(42);
+}
+''');
+    return _getErrorsForFile(file).then((List<AnalysisError> errors) {
+      expect(errors, isEmpty);
+    });
+  }
+
   test_hasErrors() {
     addTestFile('''
 main() {
   print(42)
 }
 ''');
-    return getErrors().then((List<AnalysisError> errors) {
+    return _getErrors().then((List<AnalysisError> errors) {
       expect(errors, hasLength(1));
       {
         AnalysisError error = errors[0];
         expect(error.severity, 'ERROR');
         expect(error.type, 'SYNTACTIC_ERROR');
         expect(error.location.file, testFile);
         expect(error.location.startLine, 2);
       }
     });
   }
 
   test_noErrors() {
     addTestFile('''
 main() {
   print(42);
 }
 ''');
-    return getErrors().then((List<AnalysisError> errors) {
+    return _getErrors().then((List<AnalysisError> errors) {
       expect(errors, isEmpty);
     });
   }
 
-  test_fileWithoutContext() {
-    String file = '/outside.dart';
-    addFile(file, '''
+  test_removeContextAfterRequest() {
+    addTestFile('''
 main() {
-  print(42);
+  print(42)
 }
 ''');
-    return getErrorsForFile(file).then((List<AnalysisError> errors) {
-      expect(errors, isEmpty);
+    _sendGetErrorsRequest(testFile);
+    {
+      Folder projectFolder = resourceProvider.getResource(projectPath);
+      server.contextDirectoryManager.removeContext(projectFolder);
+    }
+    return _waitForResponse().then((Response response) {
+      expect(response.getResult(ERRORS), isEmpty);
+      RequestError error = response.error;
+      expect(error, isNotNull);
+      expect(error.code, -13);
     });
   }
+
+  Future<List<AnalysisError>> _getErrors() {
+    return _getErrorsForFile(testFile);
+  }
+
+  Future<List<AnalysisError>> _getErrorsForFile(String file) {
+    _sendGetErrorsRequest(file);
+    return waitForTasksFinished().then((_) {

[Paul Berry, 2014/07/23 15:06:51]

Shouldn't just "return _waitForGetErrorsResponse();" be sufficient?

[scheglov, 2014/07/24 16:54:04]

Yes, it is sufficient.
Thanks.

+      return _waitForGetErrorsResponse();
+    });
+  }
+
+  void _sendGetErrorsRequest(String file) {
+    Request request = new Request(requestId, ANALYSIS_GET_ERRORS);
+    request.setParameter(FILE, file);
+    server.handleRequest(request);
+  }
+
+  Future<List<AnalysisError>> _waitForGetErrorsResponse() {
+    return _waitForResponse().then((Response response) {
+      List errorsJsons = response.getResult(ERRORS);
+      return errorsJsons.map(AnalysisError.fromJson).toList();
+    });
+  }
+
+  Future<Response> _waitForResponse() {
+    waitForResponse() {

[Paul Berry, 2014/07/23 15:06:51]

It seems unfortunate that we have to busy wait for the response like this.  Is
there any way we could make the tests use MockServerChannel.sendRequest(), which
already contains the necessary logic to wait for the response using conventional
Dart streams?

[scheglov, 2014/07/24 16:54:04]

OK

Although I have to duplicate some code to simulate a case when the context is
remove between receiving request and analysis finished.

+      for (Response response in serverChannel.responsesReceived) {
+        if (response.id == requestId) {
+          return response;
+        }
+      }
+      return new Future(waitForResponse);
+    }
+    return new Future(waitForResponse);
+  }
 }