Add support for built-in plugins

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(BuiltInPluginInfoTest);
+    defineReflectiveTests(DiscoveredPluginInfoTest);
     defineReflectiveTests(PluginManagerTest);
     defineReflectiveTests(PluginManagerFromDiskTest);
     defineReflectiveTests(PluginSessionTest);
     defineReflectiveTests(PluginSessionFromDiskTest);
   });
 }
 
 @reflectiveTest
-class PluginInfoTest {
+class BuiltInPluginInfoTest {
+  TestNotificationManager notificationManager;
+  BuiltInPluginInfo plugin;
+
+  void setUp() {
+    notificationManager = new TestNotificationManager();
+    plugin = new BuiltInPluginInfo(null, 'test plugin', notificationManager,
+        InstrumentationService.NULL_SERVICE);
+  }
+
+  test_addContextRoot() {
+    ContextRoot contextRoot1 = new ContextRoot('/pkg1', []);
+    plugin.addContextRoot(contextRoot1);
+    expect(plugin.contextRoots, [contextRoot1]);
+    plugin.addContextRoot(contextRoot1);
+    expect(plugin.contextRoots, [contextRoot1]);
+  }
+
+  test_creation() {
+    expect(plugin.pluginId, 'test plugin');
+    expect(plugin.notificationManager, notificationManager);
+    expect(plugin.contextRoots, isEmpty);
+    expect(plugin.currentSession, isNull);
+  }
+
+  test_removeContextRoot() {
+    ContextRoot contextRoot1 = new ContextRoot('/pkg1', []);
+    ContextRoot contextRoot2 = new ContextRoot('/pkg2', []);
+    plugin.addContextRoot(contextRoot1);
+    expect(plugin.contextRoots, unorderedEquals([contextRoot1]));
+    plugin.addContextRoot(contextRoot2);
+    expect(plugin.contextRoots, unorderedEquals([contextRoot1, contextRoot2]));
+    plugin.removeContextRoot(contextRoot1);
+    expect(plugin.contextRoots, unorderedEquals([contextRoot2]));
+    plugin.removeContextRoot(contextRoot2);
+    expect(plugin.contextRoots, isEmpty);
+  }
+
+  @failingTest
+  test_start_notRunning() {
+    fail('Not tested');
+  }
+
+  test_start_running() async {
+    plugin.currentSession = new PluginSession(plugin);
+    try {
+      await plugin.start('');
+      fail('Expected a StateError');
+    } on StateError {
+      // Expected.
+    }
+  }
+
+  test_stop_notRunning() {
+    expect(() => plugin.stop(), throwsA(new isInstanceOf<StateError>()));
+  }
+
+  test_stop_running() {
+    PluginSession session = new PluginSession(plugin);
+    TestServerCommunicationChannel channel =
+        new TestServerCommunicationChannel(session);
+    plugin.currentSession = session;
+    plugin.stop();
+    expect(plugin.currentSession, isNull);
+    expect(channel.sentRequests, hasLength(1));
+    expect(channel.sentRequests[0].method, 'plugin.shutdown');
+  }
+}
+
+@reflectiveTest
+class DiscoveredPluginInfoTest {
   MemoryResourceProvider resourceProvider;
   TestNotificationManager notificationManager;
   String pluginPath = '/pluginDir';
   String executionPath = '/pluginDir/bin/plugin.dart';
   String packagesPath = '/pluginDir/.packages';
-  PluginInfo plugin;
+  DiscoveredPluginInfo plugin;
 
   void setUp() {
     resourceProvider = new MemoryResourceProvider();
     notificationManager = new TestNotificationManager();
-    plugin = new PluginInfo(pluginPath, executionPath, packagesPath,
+    plugin = new DiscoveredPluginInfo(pluginPath, executionPath, packagesPath,
         notificationManager, InstrumentationService.NULL_SERVICE);
   }
 
   test_addContextRoot() {
     ContextRoot contextRoot1 = new ContextRoot('/pkg1', []);
     plugin.addContextRoot(contextRoot1);
     expect(plugin.contextRoots, [contextRoot1]);
     plugin.addContextRoot(contextRoot1);
     expect(plugin.contextRoots, [contextRoot1]);
   }
@@ skipping 126 matching lines @@
     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'));
+              watcher.ChangeType.MODIFY, path.join(pkgPath, '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, []);
                 await manager.addPluginToContextRoot(contextRoot, plugin1Path);
                 await manager.addPluginToContextRoot(contextRoot, plugin2Path);
 
                 List<PluginInfo> plugins =
                     manager.pluginsForContextRoot(contextRoot);
                 expect(plugins, hasLength(2));
-                List<String> paths =
-                    plugins.map((PluginInfo plugin) => plugin.path).toList();
+                List<String> paths = plugins
+                    .map((PluginInfo plugin) => plugin.pluginId)
+                    .toList();
                 expect(paths, unorderedEquals([plugin1Path, plugin2Path]));
 
                 await manager.stopAll();
               });
         });
     pkg1Dir.deleteSync(recursive: true);
   }
 
   test_pluginsForContextRoot_one() async {
     io.Directory pkg1Dir = io.Directory.systemTemp.createTempSync('pkg1');
     String pkgPath = pkg1Dir.resolveSymbolicLinksSync();
     await withPlugin(test: (String pluginPath) async {
       ContextRoot contextRoot = new ContextRoot(pkgPath, []);
       await manager.addPluginToContextRoot(contextRoot, pluginPath);
 
       List<PluginInfo> plugins = manager.pluginsForContextRoot(contextRoot);
       expect(plugins, hasLength(1));
-      expect(plugins[0].path, pluginPath);
+      expect(plugins[0].pluginId, pluginPath);
 
       await manager.stopAll();
     });
     pkg1Dir.deleteSync(recursive: true);
   }
 
   test_removedContextRoot() async {
     io.Directory pkg1Dir = io.Directory.systemTemp.createTempSync('pkg1');
     String pkgPath = pkg1Dir.resolveSymbolicLinksSync();
     await withPlugin(test: (String pluginPath) async {
@@ skipping 48 matching lines @@
 }
 
 @reflectiveTest
 class PluginSessionFromDiskTest extends PluginTestSupport {
   test_start_notRunning() async {
     await withPlugin(test: (String pluginPath) async {
       String packagesPath = path.join(pluginPath, '.packages');
       String mainPath = path.join(pluginPath, 'bin', 'plugin.dart');
       String byteStorePath = path.join(pluginPath, 'byteStore');
       new io.Directory(byteStorePath).createSync();
-      PluginInfo plugin = new PluginInfo(pluginPath, mainPath, packagesPath,
-          notificationManager, InstrumentationService.NULL_SERVICE);
+      PluginInfo plugin = new DiscoveredPluginInfo(
+          pluginPath,
+          mainPath,
+          packagesPath,
+          notificationManager,
+          InstrumentationService.NULL_SERVICE);
       PluginSession session = new PluginSession(plugin);
       plugin.currentSession = session;
       expect(await session.start(byteStorePath), isTrue);
       await session.stop();
     });
   }
 }
 
 @reflectiveTest
 class PluginSessionTest {
   MemoryResourceProvider resourceProvider;
   TestNotificationManager notificationManager;
   String pluginPath = '/pluginDir';
   String executionPath = '/pluginDir/bin/plugin.dart';
   String packagesPath = '/pluginDir/.packages';
   PluginInfo plugin;
   PluginSession session;
 
   void setUp() {
     resourceProvider = new MemoryResourceProvider();
     notificationManager = new TestNotificationManager();
-    plugin = new PluginInfo(pluginPath, executionPath, packagesPath,
+    plugin = new DiscoveredPluginInfo(pluginPath, executionPath, packagesPath,
         notificationManager, InstrumentationService.NULL_SERVICE);
     session = new PluginSession(plugin);
   }
 
   void test_handleNotification() {
     Notification notification =
         new AnalysisErrorsParams('/test.dart', <AnalysisError>[])
             .toNotification();
     expect(notificationManager.notifications, hasLength(0));
     session.handleNotification(notification);
@@ skipping 260 matching lines @@
       void onNotification(Notification notification),
       {Function onError, void onDone()}) {
     fail('Unexpected invocation of listen');
   }
 
   @override
   void sendRequest(Request request) {
     sentRequests.add(request);
   }
 }