More integration tests for analysis server.

pkg/analysis_server/test/integration/integration_tests.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.integration.analysis;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 16 matching lines @@
   Directory sourceDirectory;
 
   /**
    * Map from file path to the list of analysis errors which have most recently
    * been received for the file.
    */
   HashMap<String, dynamic> currentAnalysisErrors = new HashMap<String, dynamic>(
       );
 
   /**
-   * Create a source file with the given contents.  [relativePath]
+   * Write a source file with the given contents.  [relativePath]
    * is relative to [sourceDirectory]; on Windows any forward slashes it
    * contains are converted to backslashes.
+   *
+   * If the file didn't previously exist, it is created.  If it did, it is
+   * overwritten.
    */
-  void createFile(String relativePath, String contents) {
+  void writeFile(String relativePath, String contents) {
     String absolutePath = normalizePath(relativePath);
     new Directory(dirname(absolutePath)).createSync(recursive: true);
     new File(absolutePath).writeAsStringSync(contents);
   }
 
   /**
    * Convert the given [relativePath] to an absolute path, by interpreting it
    * relative to [sourceDirectory].  On Windows any forward slashes in
    * [relativePath] are converted to backslashes.
    */
   String normalizePath(String relativePath) {
     return join(sourceDirectory.path, relativePath.replaceAll('/', separator));
   }
 
   /**
    * Send the server an 'analysis.setAnalysisRoots' command.
    */
   Future setAnalysisRoots(List<String> relativeRoots) {
     return server.send('analysis.setAnalysisRoots', {
       'included': relativeRoots.map(normalizePath).toList(),
       'excluded': []
     });
   }
 
   /**
+   * Send the server a 'server.setSubscriptions' command.
+   */
+  Future server_setSubscriptions(List<String> subscriptions) {
+    return server.send('server.setSubscriptions', {
+      'subscriptions': subscriptions
+    });
+  }
+
+  /**
    * Return a future which will complete when a 'server.status' notification is
    * received from the server with 'analyzing' set to false.
    *
    * The future will only be completed by 'server.status' notifications that are
    * received after this function call.  So it is safe to use this getter
    * multiple times in one test; each time it is used it will wait afresh for
    * analysis to finish.
    */
   Future get analysisFinished {
     Completer completer = new Completer();
     StreamSubscription subscription;
     subscription = server.onNotification('server.status').listen((params) {
-      if (!params['analysis']['analyzing']) {
+      bool analysisComplete = false;
+      try {
+        analysisComplete = !params['analysis']['analyzing'];
+      } catch (_) {
+        // Status message was mal-formed or missing optional parameters.  That's
+        // fine, since we'll detect a mal-formed status message below.
+      }
+      if (analysisComplete) {
         completer.complete(params);
         subscription.cancel();
       }
+      expect(params, isServerStatusParams);
     });
     return completer.future;
   }
 
   /**
    * Print out any messages exchanged with the server.  If some messages have
    * already been exchanged with the server, they are printed out immediately.
    */
   void debugStdio() {
     server.debugStdio();
@@ skipping 24 matching lines @@
     });
   }
 }
 
 // Matchers for data types defined in the analysis server API
 // ==========================================================
 // TODO(paulberry): add more matchers.
 
 const Matcher isString = const isInstanceOf<String>('String');
 
-const Matcher isInt = const isInstanceOf<int>('Int');
+const Matcher isInt = const isInstanceOf<int>('int');
 
-const Matcher isResultResponse = const MatchesJsonObject('result response', const {
+const Matcher isBool = const isInstanceOf<bool>('bool');
+
+const Matcher isResultResponse = const MatchesJsonObject('result response',
+    const {
   'id': isString
 }, optionalFields: const {
   'result': anything
 });
 
 const Matcher isError = const MatchesJsonObject('Error', const {
   // TODO(paulberry): once we decide what the set of permitted error codes are,
   // add validation for 'code'.
   'code': anything,
-  'message': isString,
+  'message': isString
+}, optionalFields: const {
+  // TODO(paulberry): API spec says that 'data' is required, but sometimes we
+  // don't see it (example: error "Expected parameter subscriptions to be a
+  // string list map" in response to a malformed "analysis.setSubscriptions"
+  // command).
   'data': anything
 });
 
-const Matcher isErrorResponse = const MatchesJsonObject('error response', const {
+const Matcher isErrorResponse = const MatchesJsonObject('error response', const
+    {
   'id': isString,
   'error': isError
 });
 
 const Matcher isNotification = const MatchesJsonObject('notification', const {
   'event': isString
 }, optionalFields: const {
   'params': isMap
 });
 
+const Matcher isServerGetVersionResult = const MatchesJsonObject(
+    'server.getVersion result', const {
+  'version': isString
+});
+
+const Matcher isServerStatusParams = const MatchesJsonObject(
+    'server.status params', null, optionalFields: const {
+  'analysis': isAnalysisStatus
+});
+
 final Matcher isErrorSeverity = isIn(['INFO', 'WARNING', 'ERROR']);
 
 final Matcher isErrorType = isIn(['COMPILE_TIME_ERROR', 'HINT',
     'STATIC_TYPE_WARNING', 'STATIC_WARNING', 'SYNTACTIC_ERROR', 'TODO']);
 
 const Matcher isLocation = const MatchesJsonObject('Location', const {
   'file': isString,
   'offset': isInt,
   'length': isInt,
   'startLine': isInt,
   'startColumn': isInt
 });
 
 final Matcher isAnalysisError = new MatchesJsonObject('AnalysisError', {
   'severity': isErrorSeverity,
   'type': isErrorType,
   'location': isLocation,
   'message': isString,
 }, optionalFields: {
   'correction': isString,
   // TODO(paulberry): remove 'errorCode' once server stops sending it
   'errorCode': anything
 });
 
+const Matcher isAnalysisStatus = const MatchesJsonObject('AnalysisStatus', const
+    {
+  'analyzing': isBool
+}, optionalFields: const {
+  'analysisTarget': isString
+});
+
 
 /**
  * Type of closures used by MatchesJsonObject to record field mismatches.
  */
 typedef Description MismatchDescriber(Description mismatchDescription, bool
     verbose);
 
 /**
  * Matcher that matches a JSON object, with a given set of required and
  * optional fields, and their associated types (expressed as [Matcher]s).
@@ skipping 90 matching lines @@
    * [valueMatcher].  If it doesn't match, record a closure in [mismatches]
    * which can describe the mismatch.
    */
   void _checkField(String key, value, Matcher
       valueMatcher, List<MismatchDescriber> mismatches) {
     Map subState = {};
     if (!valueMatcher.matches(value, subState)) {
       mismatches.add((Description mismatchDescription, bool verbose) {
         mismatchDescription = mismatchDescription.add(
             'contains malformed field ').addDescriptionOf(key).add(' (should be '
-            ).addDescriptionOf(valueMatcher).add('; ');
-        mismatchDescription = valueMatcher.describeMismatch(value,
-            mismatchDescription, subState, verbose);
+            ).addDescriptionOf(valueMatcher);
+        String subDescription = valueMatcher.describeMismatch(value,
+            new StringDescription(), subState, false).toString();
+        if (subDescription.isNotEmpty) {
+          mismatchDescription = mismatchDescription.add('; ').add(subDescription
+              );
+        }
         return mismatchDescription.add(')');
       });
     }
   }
 }
 
 /**
  * Instances of the class [Server] manage a connection to a server process, and
  * facilitate communication to and from the server.
  */
@@ skipping 86 matching lines @@
           expect(messageAsMap['id'], isString);
           String id = message['id'];
           Completer completer = server._pendingCommands[id];
           if (completer == null) {
             fail('Unexpected response from server: id=$id');
           } else {
             server._pendingCommands.remove(id);
           }
           if (messageAsMap.containsKey('error')) {
             // TODO(paulberry): propagate the error info to the completer.
-            completer.completeError(null);
+            completer.completeError(new UnimplementedError(
+                'Server responded with an error'));
             // Check that the message is well-formed.  We do this after calling
             // completer.completeError() so that we don't stall the test in the
             // event of an error.
             expect(message, isErrorResponse);
           } else {
             completer.complete(messageAsMap['result']);
             // Check that the message is well-formed.  We do this after calling
             // completer.complete() so that we don't stall the test in the
             // event of an error.
             expect(message, isResultResponse);
@@ skipping 73 matching lines @@
    * Record a message that was exchanged with the server, and print it out if
    * [debugStdio] has been called.
    */
   void _recordStdio(String line) {
     if (_debuggingStdio) {
       print(line);
     }
     _recordedStdio.add(line);
   }
 }