Move more behavior out of ContextManagerCallbacks and into ContextManager

pkg/analysis_server/test/context_manager_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.context.directory.manager;
 
 import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_io.dart';
+import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:linter/src/plugin/linter_plugin.dart';
 import 'package:linter/src/rules/avoid_as.dart';
-import 'package:package_config/packages.dart';
 import 'package:path/path.dart';
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
+import 'mock_sdk.dart';
 import 'mocks.dart';
 import 'utils.dart';
 
 main() {
   initializeTestEnvironment();
   defineReflectiveTests(AbstractContextManagerTest);
 }
 
 @reflectiveTest
 class AbstractContextManagerTest {
@@ skipping 64 matching lines @@
         .toList();
   }
 
   List<ErrorProcessor> get errorProcessors => callbacks.currentContext
       .getConfigurationData(CONFIGURED_ERROR_PROCESSORS);
 
   List<Linter> get lints => getLints(callbacks.currentContext);
 
   AnalysisOptions get options => callbacks.currentContext.analysisOptions;
 
+  Map<String, List<Folder>> get _currentPackageMap => _packageMap(projPath);
+
   void deleteFile(List<String> pathComponents) {
     String filePath = posix.joinAll(pathComponents);
     resourceProvider.deleteFile(filePath);
   }
 
   ErrorProcessor getProcessor(AnalysisError error) =>
       ErrorProcessor.getProcessor(callbacks.currentContext, error);
 
   String newFile(List<String> pathComponents, [String content = '']) {
     String filePath = posix.joinAll(pathComponents);
@@ skipping 18 matching lines @@
   }
 
   UriResolver provideEmbeddedUriResolver(Folder folder) => embeddedUriResolver;
 
   UriResolver providePackageResolver(Folder folder) => packageResolver;
 
   void setUp() {
     processRequiredPlugins();
     resourceProvider = new MemoryResourceProvider();
     packageMapProvider = new MockPackageMapProvider();
+    DartSdkManager sdkManager = new DartSdkManager(() {
+      return new MockSdk();
+    });
     manager = new ContextManagerImpl(
         resourceProvider,
+        sdkManager,
         providePackageResolver,
         provideEmbeddedUriResolver,
         packageMapProvider,
         analysisFilesGlobs,
         InstrumentationService.NULL_SERVICE,
         new AnalysisOptionsImpl());
     callbacks = new TestContextManagerCallbacks(resourceProvider);
     manager.callbacks = callbacks;
     resourceProvider.newFolder(projPath);
   }
@@ skipping 898 matching lines @@
   void test_setRoots_addFolderWithPackagespecAndPackageRoot() {
     // The package root should take priority.
     String packagespecPath = posix.join(projPath, '.packages');
     resourceProvider.newFile(packagespecPath,
         'unittest:file:///home/somebody/.pub/cache/unittest-0.9.9/lib/');
     String packageRootPath = '/package/root/';
     manager.setRoots(<String>[projPath], <String>[],
         <String, String>{projPath: packageRootPath});
     expect(callbacks.currentContextPaths, hasLength(1));
     expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextDispositions[projPath].packageRoot,
-        packageRootPath);
+    _checkPackageRoot(projPath, packageRootPath);
   }
 
   void test_setRoots_addFolderWithPubspec() {
     String pubspecPath = posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     expect(callbacks.currentContextPaths, hasLength(1));
     expect(callbacks.currentContextPaths, contains(projPath));
     expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
@@ skipping 90 matching lines @@
       },
     };
     // set roots
     manager.setRoots(<String>[root], <String>[], <String, String>{});
     callbacks.assertContextPaths([root, subProjectA, subProjectB]);
     // verify files
     callbacks.assertContextFiles(root, [rootFile]);
     callbacks.assertContextFiles(subProjectA, [subProjectA_file]);
     callbacks.assertContextFiles(subProjectB, [subProjectB_file]);
     // verify package maps
-    _checkPackageMap(root, isNull);
-    _checkPackageMap(
-        subProjectA, equals(packageMapProvider.packageMaps[subProjectA]));
-    _checkPackageMap(
-        subProjectB, equals(packageMapProvider.packageMaps[subProjectB]));
+    expect(_packageMap(root), isNull);
+    expect(_packageMap(subProjectA),
+        equals(packageMapProvider.packageMaps[subProjectA]));
+    expect(_packageMap(subProjectB),
+        equals(packageMapProvider.packageMaps[subProjectB]));
   }
 
   void test_setRoots_addPackageRoot() {
     String packagePathFoo = '/package1/foo';
     String packageRootPath = '/package2/foo';
     Folder packageFolder = resourceProvider.newFolder(packagePathFoo);
     packageMapProvider.packageMap = {
       'foo': [packageFolder]
     };
     List<String> includedPaths = <String>[projPath];
     List<String> excludedPaths = <String>[];
     manager.setRoots(includedPaths, excludedPaths, <String, String>{});
-    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
     manager.setRoots(includedPaths, excludedPaths,
         <String, String>{projPath: packageRootPath});
     _checkPackageRoot(projPath, equals(packageRootPath));
   }
 
   void test_setRoots_changePackageRoot() {
     String packageRootPath1 = '/package1';
     String packageRootPath2 = '/package2';
     List<String> includedPaths = <String>[projPath];
     List<String> excludedPaths = <String>[];
@@ skipping 301 matching lines @@
     _checkPackageRoot(projPath, equals(packageRootPath));
   }
 
   void test_setRoots_newlyAddedFoldersGetProperPackageMap() {
     String packagePath = '/package/foo';
     Folder packageFolder = resourceProvider.newFolder(packagePath);
     packageMapProvider.packageMap = {
       'foo': [packageFolder]
     };
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
   }
 
   void test_setRoots_noContext_excludedFolder() {
     // prepare paths
     String project = '/project';
     String excludedFolder = '$project/excluded';
     String excludedPubspec = '$excludedFolder/pubspec.yaml';
     // create files
     resourceProvider.newFile(excludedPubspec, 'name: ignore-me');
     // set "/project", and exclude "/project/excluded"
@@ skipping 167 matching lines @@
     Folder packageFolder = resourceProvider.newFolder(packagePathFoo);
     packageMapProvider.packageMap = {
       'foo': [packageFolder]
     };
     List<String> includedPaths = <String>[projPath];
     List<String> excludedPaths = <String>[];
     manager.setRoots(includedPaths, excludedPaths,
         <String, String>{projPath: packageRootPath});
     _checkPackageRoot(projPath, equals(packageRootPath));
     manager.setRoots(includedPaths, excludedPaths, <String, String>{});
-    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+    expect(_currentPackageMap, equals(packageMapProvider.packageMap));
   }
 
   void test_setRoots_rootPathContainsDotFile() {
     // If the path to the context root itself contains a folder whose name
     // begins with '.', then that is not sufficient to cause any files in the
     // context to be ignored.
     String project = '/.pub/project';
     String fileA = '$project/foo.dart';
     resourceProvider.newFile(fileA, '');
     manager.setRoots(<String>[project], <String>[], <String, String>{});
@@ skipping 517 matching lines @@
   test_watch_modifyPackageMapDependency() {
     // create a dependency file
     String dependencyPath = posix.join(projPath, 'dep');
     resourceProvider.newFile(dependencyPath, 'contents');
     packageMapProvider.dependencies.add(dependencyPath);
     // create a Dart file
     String dartFilePath = posix.join(projPath, 'main.dart');
     resourceProvider.newFile(dartFilePath, 'contents');
     // the created context has the expected empty package map
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    _checkPackageMap(projPath, isEmpty);
+    expect(_currentPackageMap, isEmpty);
     // configure package map
     String packagePath = '/package/foo';
     resourceProvider.newFolder(packagePath);
-    packageMapProvider.packageMap = {'foo': projPath};
+    packageMapProvider.packageMap = {
+      'foo': [resourceProvider.newFolder(projPath)]
+    };
     // Changing a .dart file in the project shouldn't cause a new
     // package map to be picked up.
     resourceProvider.modifyFile(dartFilePath, 'new contents');
     return pumpEventQueue().then((_) {
-      _checkPackageMap(projPath, isEmpty);
+      expect(_currentPackageMap, isEmpty);
       // However, changing the package map dependency should.
       resourceProvider.modifyFile(dependencyPath, 'new contents');
       return pumpEventQueue().then((_) {
-        _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+        expect(_currentPackageMap, equals(packageMapProvider.packageMap));
       });
     });
   }
 
   test_watch_modifyPackageMapDependency_fail() {
     // create a dependency file
     String dependencyPath = posix.join(projPath, 'dep');
     resourceProvider.newFile(dependencyPath, 'contents');
     packageMapProvider.dependencies.add(dependencyPath);
     // create a Dart file
     String dartFilePath = posix.join(projPath, 'main.dart');
     resourceProvider.newFile(dartFilePath, 'contents');
     // the created context has the expected empty package map
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    _checkPackageMap(projPath, isEmpty);
+    expect(_currentPackageMap, isEmpty);
     // Change the package map dependency so that the packageMapProvider is
     // re-run, and arrange for it to return null from computePackageMap().
     packageMapProvider.packageMap = null;
     resourceProvider.modifyFile(dependencyPath, 'new contents');
     return pumpEventQueue().then((_) {
       // The package map should have been changed to null.
-      _checkPackageMap(projPath, isNull);
+      expect(_currentPackageMap, isNull);
     });
   }
 
   test_watch_modifyPackagespec() {
     String packagesPath = '$projPath/.packages';
     String filePath = '$projPath/bin/main.dart';
 
     resourceProvider.newFile(packagesPath, '');
     resourceProvider.newFile(filePath, 'library main;');
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
-    Packages packages = callbacks.currentContextDispositions[projPath].packages;
-    expect(packages.packages, isEmpty);
+    expect(_currentPackageMap, isEmpty);
 
     // update .packages
     callbacks.now++;
     resourceProvider.modifyFile(packagesPath, 'main:./lib/');
     return pumpEventQueue().then((_) {
       // verify new package info
-      packages = callbacks.currentContextDispositions[projPath].packages;
-      expect(packages.packages, unorderedEquals(['main']));
+      expect(_currentPackageMap.keys, unorderedEquals(['main']));
     });
   }
 
   /**
    * Verify that package URI's for source files in [path] will be resolved
-   * using a package map matching [expectation].
+   * using a package root matching [expectation].
    */
-  void _checkPackageMap(String path, expectation) {
-    FolderDisposition disposition = callbacks.currentContextDispositions[path];
-    Map<String, List<Folder>> packageMap =
-        disposition is PackageMapDisposition ? disposition.packageMap : null;
-    expect(packageMap, expectation);
+  void _checkPackageRoot(String path, expectation) {
+    // TODO(brianwilkerson) Figure out how to test this. Possibly by comparing
+    // the contents of the package map (although that approach doesn't work at
+    // the moment).
+//    FolderDisposition disposition = callbacks.currentContextDispositions[path];
+//    expect(disposition.packageRoot, expectation);
+    // TODO(paulberry): we should also verify that the package map itself is
+    // correct.  See dartbug.com/23909.
   }
 
-  /**
-   * Verify that package URI's for source files in [path] will be resolved
-   * using a package root maching [expectation].
-   */
-  void _checkPackageRoot(String path, expectation) {
-    FolderDisposition disposition = callbacks.currentContextDispositions[path];
-    expect(disposition.packageRoot, expectation);
-    // TODO(paulberry): we should also verify that the package map itself is
-    // correct.  See dartbug.com/23909.
+  Map<String, List<Folder>> _packageMap(String contextPath) {
+    Folder folder = resourceProvider.getFolder(contextPath);
+    return manager.folderMap[folder]?.sourceFactory?.packageMap;
   }
 }
 
 class TestContextManagerCallbacks extends ContextManagerCallbacks {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
   /**
@@ skipping 13 matching lines @@
       <String, Map<String, int>>{};
 
   /**
    * A map from the paths of contexts to a set of the sources that should be
    * explicitly analyzed in those contexts.
    */
   final Map<String, Set<Source>> currentContextSources =
       <String, Set<Source>>{};
 
   /**
-   * Map from context to folder disposition.
-   */
-  final Map<String, FolderDisposition> currentContextDispositions =
-      <String, FolderDisposition>{};
-
-  /**
    * Resource provider used for this test.
    */
   final ResourceProvider resourceProvider;
 
   TestContextManagerCallbacks(this.resourceProvider);
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   @override
   AnalysisContext addContext(
       Folder folder, AnalysisOptions options, FolderDisposition disposition) {
     String path = folder.path;
     expect(currentContextPaths, isNot(contains(path)));
     currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
     currentContextSources[path] = new HashSet<Source>();
-    currentContextDispositions[path] = disposition;
     currentContext = AnalysisEngine.instance.createAnalysisContext();
     _locateEmbedderYamls(currentContext, disposition);
     List<UriResolver> resolvers = [];
     if (currentContext is InternalAnalysisContext) {
       EmbedderYamlLocator embedderYamlLocator =
           (currentContext as InternalAnalysisContext).embedderYamlLocator;
       EmbedderUriResolver embedderUriResolver =
           new EmbedderUriResolver(embedderYamlLocator.embedderYamls);
       if (embedderUriResolver.length > 0) {
         // We have some embedder dart: uri mappings, add the resolver
@@ skipping 46 matching lines @@
     // Do nothing.
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     String path = folder.path;
     expect(currentContextPaths, contains(path));
     currentContextTimestamps.remove(path);
     currentContextFilePaths.remove(path);
     currentContextSources.remove(path);
-    currentContextDispositions.remove(path);
   }
 
   @override
-  void updateContextPackageUriResolver(
-      Folder contextFolder, FolderDisposition disposition) {
-    currentContextDispositions[contextFolder.path] = disposition;
+  void updateContextPackageUriResolver(AnalysisContext context) {
+    // Nothing to do.
   }
 
   /// If [disposition] has a package map, attempt to locate `_embedder.yaml`
   /// files.
   void _locateEmbedderYamls(
       InternalAnalysisContext context, FolderDisposition disposition) {
     Map<String, List<Folder>> packageMap;
     if (disposition is PackageMapDisposition) {
       packageMap = disposition.packageMap;
     } else if (disposition is PackagesFileDisposition) {
@@ skipping 16 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }