Add support for watch events and error notifications

pkg/analysis_server/test/src/plugin/plugin_manager_test.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analysis_server/src/plugin/plugin_manager.dart';
 import 'package:analyzer/context/context_root.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart'
     hide ContextRoot;
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'package:watcher/watcher.dart' as watcher;
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(PluginInfoTest);
     defineReflectiveTests(PluginManagerTest);
     defineReflectiveTests(PluginManagerFromDiskTest);
     defineReflectiveTests(PluginSessionTest);
     defineReflectiveTests(PluginSessionFromDiskTest);
   });
 }
@@ skipping 102 matching lines @@
     await withPlugin(
         pluginName: 'plugin1',
         test: (String plugin1Path) async {
           await withPlugin(
               pluginName: 'plugin2',
               test: (String plugin2Path) async {
                 ContextRoot contextRoot = new ContextRoot(pkgPath, []);
                 await manager.addPluginToContextRoot(contextRoot, plugin1Path);
                 await manager.addPluginToContextRoot(contextRoot, plugin2Path);
 
-                Map<PluginInfo, Future<Response>> responses = manager.broadcast(
-                    contextRoot,
-                    new CompletionGetSuggestionsParams(
-                        '/pkg1/lib/pkg1.dart', 100));
+                Map<PluginInfo, Future<Response>> responses =
+                    manager.broadcastRequest(
+                        contextRoot,
+                        new CompletionGetSuggestionsParams(
+                            '/pkg1/lib/pkg1.dart', 100));
                 expect(responses, hasLength(2));
 
                 await manager.stopAll();
               });
         });
     pkg1Dir.deleteSync(recursive: true);
   }
 
+  test_broadcastWatchEvent() async {
+    io.Directory pkg1Dir = io.Directory.systemTemp.createTempSync('pkg1');
+    String pkgPath = pkg1Dir.resolveSymbolicLinksSync();
+    await withPlugin(
+        pluginName: 'plugin1',
+        test: (String plugin1Path) async {
+          ContextRoot contextRoot = new ContextRoot(pkgPath, []);
+          await manager.addPluginToContextRoot(contextRoot, plugin1Path);
+          List<PluginInfo> plugins = manager.pluginsForContextRoot(contextRoot);
+          expect(plugins, hasLength(1));
+          watcher.WatchEvent watchEvent = new watcher.WatchEvent(
+              watcher.ChangeType.MODIFY,
+              path.join(plugin1Path, 'lib', 'lib.dart'));
+          List<Future<Response>> responses =
+              await manager.broadcastWatchEvent(watchEvent);
+          expect(responses, hasLength(1));
+          Response response = await responses[0];
+          expect(response, isNotNull);
+          expect(response.error, isNull);
+          await manager.stopAll();
+        });
+    pkg1Dir.deleteSync(recursive: true);
+  }
+
   test_pluginsForContextRoot_multiple() async {
     io.Directory pkg1Dir = io.Directory.systemTemp.createTempSync('pkg1');
     String pkgPath = pkg1Dir.resolveSymbolicLinksSync();
     await withPlugin(
         pluginName: 'plugin1',
         test: (String plugin1Path) async {
           await withPlugin(
               pluginName: 'plugin2',
               test: (String plugin2Path) async {
                 ContextRoot contextRoot = new ContextRoot(pkgPath, []);
@@ skipping 52 matching lines @@
   PluginManager manager;
 
   void setUp() {
     resourceProvider = new MemoryResourceProvider();
     byteStorePath = '/byteStore';
     notificationManager = new TestNotificationManager();
     manager = new PluginManager(resourceProvider, byteStorePath,
         notificationManager, InstrumentationService.NULL_SERVICE);
   }
 
-  void test_broadcast_none() {
+  void test_broadcastRequest_none() {
     ContextRoot contextRoot = new ContextRoot('/pkg1', []);
-    Map<PluginInfo, Future<Response>> responses = manager.broadcast(contextRoot,
+    Map<PluginInfo, Future<Response>> responses = manager.broadcastRequest(
+        contextRoot,
         new CompletionGetSuggestionsParams('/pkg1/lib/pkg1.dart', 100));
     expect(responses, hasLength(0));
   }
 
   void test_creation() {
     expect(manager.resourceProvider, resourceProvider);
     expect(manager.byteStorePath, byteStorePath);
     expect(manager.notificationManager, notificationManager);
   }
 
@@ skipping 213 matching lines @@
   /**
    * The default content of the plugin. This is a minimal plugin that will only
    * respond correctly to version checks and to shutdown requests.
    */
   String _defaultPluginContent() {
     return r'''
 import 'dart:isolate';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer_plugin/plugin/plugin.dart';
+import 'package:analyzer_plugin/protocol/protocol_generated.dart';
 import 'package:analyzer_plugin/starter.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 void main(List<String> args, SendPort sendPort) {
   MinimalPlugin plugin = new MinimalPlugin(PhysicalResourceProvider.INSTANCE);
   new ServerPluginStarter(plugin).start(sendPort);
 }
 
 class MinimalPlugin extends ServerPlugin {
   MinimalPlugin(ResourceProvider provider) : super(provider);
 
   @override
-  List<String> get fileGlobsToAnalyze => <String>[];
+  List<String> get fileGlobsToAnalyze => <String>['**/*.dart'];
 
   @override
   String get name => 'minimal';
 
   @override
   String get version => '0.0.1';
 
   @override
+  AnalysisHandleWatchEventsResult handleAnalysisHandleWatchEvents(
+          Map<String, Object> parameters) =>
+    new AnalysisHandleWatchEventsResult();
+
+  @override
   bool isCompatibleWith(Version serverVersion) => true;
 }
 ''';
   }
 
   /**
    * Return the content to be used for the '.packages' file.
    */
   String _getPackagesFileContent() {
     if (_packagesFileContent == null) {
       io.File sdkPackagesFile = new io.File(_sdkPackagesPath());
       List<String> sdkPackageMap = sdkPackagesFile.readAsLinesSync();
       _packagesFileContent =
           _convertPackageMap(path.dirname(sdkPackagesFile.path), sdkPackageMap);
     }
     return _packagesFileContent;
   }
 
   /**
    * Return the path to the '.packages' file in the root of the SDK checkout.
    */
   String _sdkPackagesPath() {
-    String packagesPath =
-        io.Platform.script.toFilePath(windows: io.Platform.isWindows);
+    String packagesPath = io.Platform.script.toFilePath();
     while (packagesPath.isNotEmpty &&
         path.basename(packagesPath) != 'analysis_server') {
       packagesPath = path.dirname(packagesPath);
     }
     packagesPath = path.dirname(packagesPath);
     packagesPath = path.dirname(packagesPath);
     return path.join(packagesPath, '.packages');
   }
 }
 
@@ skipping 29 matching lines @@
       void onNotification(Notification notification),
       {Function onError, void onDone()}) {
     fail('Unexpected invocation of listen');
   }
 
   @override
   void sendRequest(Request request) {
     sentRequests.add(request);
   }
 }