Wait for "server.connected" notification before beginning integration tests.

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';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 /**
  * Base class for analysis server integration tests.
  */
 abstract class AbstractAnalysisServerIntegrationTest {
   /**
    * Amount of time to give the server to respond to a shutdown request before
    * forcibly terminating it.
-   *
-   * TODO(paulberry): the extra-long timeout (20s) is because sometimes the
-   * buildbots are slow to spawn a new analysis server process.  It would be
-   * better to wait for the initial "server.connected" message with a long
-   * timeout, and keep this timeout short.
-   *
    */
-  static const Duration SHUTDOWN_TIMEOUT = const Duration(seconds: 20);
+  static const Duration SHUTDOWN_TIMEOUT = const Duration(seconds: 5);
 
   /**
    * Connection to the analysis server.
    */
-  Server server;
+  final Server server = new Server();
 
   /**
    * Temporary directory in which source files can be stored.
    */
   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>(
       );
 
   /**
    * True if the teardown process should skip sending a "server.shutdown"
    * request (e.g. because the server is known to have already shutdown).
    */
   bool skipShutdown = false;
 
   /**
+   * Data associated with the "server.connected" notification that was received
+   * when the server started up.
+   */
+  var serverConnectedParams;
+
+  /**
    * 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 writeFile(String relativePath, String contents) {
     String absolutePath = normalizePath(relativePath);
     new Directory(dirname(absolutePath)).createSync(recursive: true);
@@ skipping 64 matching lines @@
   void debugStdio() {
     server.debugStdio();
   }
 
   /**
    * The server is automatically started before every test, and a temporary
    * [sourceDirectory] is created.
    */
   Future setUp() {
     sourceDirectory = Directory.systemTemp.createTempSync('analysisServer');
-    return Server.start().then((Server server) {
-      this.server = server;
-      server.onNotification(ANALYSIS_ERRORS).listen((params) {
-        expect(params, isMap);
-        expect(params['file'], isString);
-        currentAnalysisErrors[params['file']] = params['errors'];
-      });
+
+    server.onNotification(ANALYSIS_ERRORS).listen((params) {
+      expect(params, isMap);
+      expect(params['file'], isString);
+      currentAnalysisErrors[params['file']] = params['errors'];
+    });
+    Completer serverConnected = new Completer();
+    server.onNotification(SERVER_CONNECTED).listen((_) {
+      expect(serverConnected.isCompleted, isFalse);
+      serverConnected.complete();
+    });
+    return server.start().then((params) {
+      serverConnectedParams = params;
       server.exitCode.then((_) { skipShutdown = true; });
+      return serverConnected.future;
     });
   }
 
   /**
    * After every test, the server is stopped and [sourceDirectory] is deleted.
    */
   Future tearDown() {
     return _shutdownIfNeeded().then((_) {
       sourceDirectory.deleteSync(recursive: true);
     });
@@ skipping 303 matching lines @@
 }
 
 Matcher isListOf(Matcher elementMatcher) => new _ListOf(elementMatcher);
 
 /**
  * Instances of the class [Server] manage a connection to a server process, and
  * facilitate communication to and from the server.
  */
 class Server {
   /**
-   * Server process object.
+   * Server process object, or null if server hasn't been started yet.
    */
-  Process _process;
+  Process _process = null;
 
   /**
    * Commands that have been sent to the server but not yet acknowledged, and
    * the [Completer] objects which should be completed when acknowledgement is
    * received.
    */
   final HashMap<String, Completer> _pendingCommands = <String, Completer> {};
 
   /**
    * Number which should be used to compute the 'id' to send in the next command
@@ skipping 31 matching lines @@
    * True if we've received bad data from the server, and we are aborting the
    * test.
    */
   bool _receivedBadDataFromServer = false;
 
   /**
    * Stopwatch that we use to generate timing information for debug output.
    */
   Stopwatch _time = new Stopwatch();
 
-  Server._(this._process) {
-    _time.start();
-  }
-
   /**
    * Get a stream which will receive notifications of the given event type.
    * The values delivered to the stream will be the contents of the 'params'
    * field of the notification message.
    */
   Stream onNotification(String event) {
     Stream notificationStream = _notificationStreams[event];
     if (notificationStream == null) {
       StreamController notificationController = new StreamController();
       _notificationControllers[event] = notificationController;
       notificationStream = notificationController.stream.asBroadcastStream();
       _notificationStreams[event] = notificationStream;
     }
     return notificationStream;
   }
 
   /**
    * Start the server.  If [debugServer] is true, the server will be started
    * with "--debug", allowing a debugger to be attached.
    */
-  static Future<Server> start({bool debugServer: false}) {
+  Future start({bool debugServer: false}) {
+    if (_process != null) {
+      throw new Exception('Process already started');
+    }
+    _time.start();
     // TODO(paulberry): move the logic for finding the script, the dart
     // executable, and the package root into a shell script.
     String dartBinary = Platform.executable;
     String scriptDir = dirname(Platform.script.toFilePath(windows:
         Platform.isWindows));
     String serverPath = normalize(join(scriptDir, '..', '..', 'bin',
         'server.dart'));
     List<String> arguments = [];
     if (debugServer) {
       arguments.add('--debug');
     }
     if (Platform.packageRoot.isNotEmpty) {
       arguments.add('--package-root=${Platform.packageRoot}');
     }
     arguments.add(serverPath);
     return Process.start(dartBinary, arguments).then((Process process) {
-      Server server = new Server._(process);
+      _process = process;
       process.stdout.transform((new Utf8Codec()).decoder).transform(
           new LineSplitter()).listen((String line) {
         String trimmedLine = line.trim();
-        server._recordStdio('RECV: $trimmedLine');
+        _recordStdio('RECV: $trimmedLine');
         var message;
         try {
           message = JSON.decoder.convert(trimmedLine);
         } catch (exception) {
-          server._badDataFromServer();
+          _badDataFromServer();
           return;
         }
         expect(message, isMap);
         Map messageAsMap = message;
         if (messageAsMap.containsKey('id')) {
           expect(messageAsMap['id'], isString);
           String id = message['id'];
-          Completer completer = server._pendingCommands[id];
+          Completer completer = _pendingCommands[id];
           if (completer == null) {
             fail('Unexpected response from server: id=$id');
           } else {
-            server._pendingCommands.remove(id);
+            _pendingCommands.remove(id);
           }
           if (messageAsMap.containsKey('error')) {
             // TODO(paulberry): propagate the error info to the completer.
             completer.completeError(new UnimplementedError(
                 'Server responded with an error'));
           } else {
             completer.complete(messageAsMap['result']);
           }
           // Check that the message is well-formed.  We do this after calling
           // completer.complete() or completer.completeError() so that we don't
           // stall the test in the event of an error.
           expect(message, isResponse);
         } else {
           // Message is a notification.  It should have an event and possibly
           // params.
           expect(messageAsMap, contains('event'));
           expect(messageAsMap['event'], isString);
           String event = messageAsMap['event'];
           StreamController notificationController =
-              server._notificationControllers[event];
+              _notificationControllers[event];
           if (notificationController != null) {
             notificationController.add(messageAsMap['params']);
           }
           // Check that the message is well-formed.  We do this after calling
           // notificationController.add() so that we don't stall the test in the
           // event of an error.
           expect(message, isNotification);
         }
       });
       process.stderr.transform((new Utf8Codec()).decoder).transform(
           new LineSplitter()).listen((String line) {
         String trimmedLine = line.trim();
-        server._recordStdio('ERR:  $trimmedLine');
-        server._badDataFromServer();
+        _recordStdio('ERR:  $trimmedLine');
+        _badDataFromServer();
       });
       process.exitCode.then((int code) {
-        server._recordStdio('TERMINATED WITH EXIT CODE $code');
+        _recordStdio('TERMINATED WITH EXIT CODE $code');
         if (code != 0) {
-          server._badDataFromServer();
+          _badDataFromServer();
         }
       });
-      return server;
     });
   }
 
   /**
    * Future that completes when the server process exits.
    */
   Future<int> get exitCode => _process.exitCode;
 
   /**
    * Stop the server.
@@ skipping 70 matching lines @@
    */
   void _recordStdio(String line) {
     double elapsedTime = _time.elapsedTicks / _time.frequency;
     line = "$elapsedTime: $line";
     if (_debuggingStdio) {
       print(line);
     }
     _recordedStdio.add(line);
   }
 }