Fix for subscribing for notifications for files in packages.

pkg/analysis_server/test/analysis_server_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.analysis_server;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/domain_server.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/protocol.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/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import 'mock_sdk.dart';
 import 'mocks.dart';
 import 'reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisServerTest);
 }
 
 @reflectiveTest
 class AnalysisServerTest {
   MockServerChannel channel;
   AnalysisServer server;
   MemoryResourceProvider resourceProvider;
+  MockPackageMapProvider packageMapProvider;
 
   /**
    * Verify that getAnalysisContextForSource returns the correct contexts even
    * for sources that are included by multiple contexts.
    *
    * See dartbug.com/21898
    */
   Future fail_getAnalysisContextForSource_crossImports() {
     // Subscribe to STATUS so we'll know when analysis is done.
     server.serverServices = [ServerService.STATUS].toSet();
@@ skipping 58 matching lines @@
       expect(fooContext.getKindOf(fooSource), SourceKind.LIBRARY);
       expect(fooContext.getKindOf(barSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(fooSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(barSource), SourceKind.LIBRARY);
     });
   }
 
   void setUp() {
     channel = new MockServerChannel();
     resourceProvider = new MemoryResourceProvider();
-    server = new AnalysisServer(channel, resourceProvider,
-        new MockPackageMapProvider(), null, new AnalysisServerOptions(),
-        new MockSdk(), InstrumentationService.NULL_SERVICE,
-        rethrowExceptions: true);
+    packageMapProvider = new MockPackageMapProvider();
+    server = new AnalysisServer(channel, resourceProvider, packageMapProvider,
+        null, new AnalysisServerOptions(), new MockSdk(),
+        InstrumentationService.NULL_SERVICE, rethrowExceptions: true);
   }
 
   Future test_contextDisposed() {
     resourceProvider.newFolder('/foo');
     resourceProvider.newFile('/foo/bar.dart', 'library lib;');
     server.setAnalysisRoots('0', ['/foo'], [], {});
     AnalysisContext context;
     return pumpEventQueue().then((_) {
       context = server.getAnalysisContext('/foo/bar.dart');
       server.setAnalysisRoots('1', [], [], {});
@@ skipping 53 matching lines @@
 
   Future test_echo() {
     server.handlers = [new EchoHandler()];
     var request = new Request('my22', 'echo');
     return channel.sendRequest(request).then((Response response) {
       expect(response.id, equals('my22'));
       expect(response.error, isNull);
     });
   }
 
-  test_getAnalysisContext_nested() {
-    String dir1Path = '/dir1';
-    String dir2Path = dir1Path + '/dir2';
-    String filePath = dir2Path + '/file.dart';
-    Folder dir1 = resourceProvider.newFolder(dir1Path);
-    Folder dir2 = resourceProvider.newFolder(dir2Path);
-    resourceProvider.newFile(filePath, 'library lib;');
-
-    AnalysisContext context1 = AnalysisEngine.instance.createAnalysisContext();
-    AnalysisContext context2 = AnalysisEngine.instance.createAnalysisContext();
-    server.folderMap[dir1] = context1;
-    server.folderMap[dir2] = context2;
-
-    expect(server.getAnalysisContext(filePath), context2);
-  }
-
-  test_getAnalysisContext_simple() {
-    String dirPath = '/dir';
-    String filePath = dirPath + '/file.dart';
-    Folder dir = resourceProvider.newFolder(dirPath);
-    resourceProvider.newFile(filePath, 'library lib;');
-
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    server.folderMap[dir] = context;
-
-    expect(server.getAnalysisContext(filePath), context);
-  }
-
   Future test_getAnalysisContextForSource() {
     // Subscribe to STATUS so we'll know when analysis is done.
     server.serverServices = [ServerService.STATUS].toSet();
     // Analyze project foo containing foo.dart and project bar containing
     // bar.dart.
     resourceProvider.newFolder('/foo');
     resourceProvider.newFolder('/bar');
     File foo = resourceProvider.newFile('/foo/foo.dart', 'library lib;');
     Source fooSource = foo.createSource();
     File bar = resourceProvider.newFile('/bar/bar.dart', 'library lib;');
     Source barSource = bar.createSource();
     server.setAnalysisRoots('0', ['/foo', '/bar'], [], {});
     return pumpEventQueue(40).then((_) {
       expect(server.statusAnalyzing, isFalse);
       // Make sure getAnalysisContext returns the proper context for each.
       AnalysisContext fooContext =
           server.getAnalysisContextForSource(fooSource);
       expect(fooContext, isNotNull);
       AnalysisContext barContext =
           server.getAnalysisContextForSource(barSource);
       expect(barContext, isNotNull);
       expect(fooContext, isNot(same(barContext)));
       expect(fooContext.getKindOf(fooSource), SourceKind.LIBRARY);
       expect(fooContext.getKindOf(barSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(fooSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(barSource), SourceKind.LIBRARY);
     });
   }
 
+  test_getContextSourcePair_nested() {
+    String dir1Path = '/dir1';
+    String dir2Path = dir1Path + '/dir2';
+    String filePath = dir2Path + '/file.dart';
+    Folder dir1 = resourceProvider.newFolder(dir1Path);
+    Folder dir2 = resourceProvider.newFolder(dir2Path);
+    resourceProvider.newFile(filePath, 'library lib;');
+
+    AnalysisContext context1 = AnalysisEngine.instance.createAnalysisContext();
+    AnalysisContext context2 = AnalysisEngine.instance.createAnalysisContext();
+    _configureSourceFactory(context1);
+    _configureSourceFactory(context2);
+    server.folderMap[dir1] = context1;
+    server.folderMap[dir2] = context2;
+
+    ContextSourcePair pair = server.getContextSourcePair(filePath);
+    Source source = pair.source;
+    expect(pair.context, same(context2));
+    expect(source, isNotNull);
+    expect(source.uri.scheme, 'file');
+    expect(source.fullName, filePath);
+  }
+
+  test_getContextSourcePair_package_inRoot() {
+    String rootPath = '/my_package';
+    String filePath = rootPath + '/lib/file.dart';
+    Folder rootFolder = resourceProvider.newFolder(rootPath);
+    resourceProvider.newFile(filePath, 'library lib;');
+
+    packageMapProvider.packageMap = <String, List<Folder>>{
+      'my_package': <Folder>[rootFolder]
+    };
+
+    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
+    _configureSourceFactory(context);
+    server.folderMap[rootFolder] = context;
+
+    ContextSourcePair pair = server.getContextSourcePair(filePath);
+    Source source = pair.source;
+    expect(pair.context, same(context));
+    expect(source, isNotNull);
+    expect(source.uri.scheme, 'package');
+    expect(source.fullName, filePath);
+  }
+
+  test_getContextSourcePair_simple() {
+    String dirPath = '/dir';
+    String filePath = dirPath + '/file.dart';
+    Folder dir = resourceProvider.newFolder(dirPath);
+    resourceProvider.newFile(filePath, 'library lib;');
+
+    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
+    _configureSourceFactory(context);
+    server.folderMap[dir] = context;
+
+    ContextSourcePair pair = server.getContextSourcePair(filePath);
+    Source source = pair.source;
+    expect(pair.context, same(context));
+    expect(source, isNotNull);
+    expect(source.uri.scheme, 'file');
+    expect(source.fullName, filePath);
+  }
+
   /**
    * Test that having multiple analysis contexts analyze the same file doesn't
    * cause that file to receive duplicate notifications when it's modified.
    */
   Future test_no_duplicate_notifications() async {
     // Subscribe to STATUS so we'll know when analysis is done.
     server.serverServices = [ServerService.STATUS].toSet();
     resourceProvider.newFolder('/foo');
     resourceProvider.newFolder('/bar');
     resourceProvider.newFile('/foo/foo.dart', 'import "../bar/bar.dart";');
@@ skipping 147 matching lines @@
   }
 
   Future test_unknownRequest() {
     server.handlers = [new EchoHandler()];
     var request = new Request('my22', 'randomRequest');
     return channel.sendRequest(request).then((Response response) {
       expect(response.id, equals('my22'));
       expect(response.error, isNotNull);
     });
   }
+
+  void _configureSourceFactory(AnalysisContext context) {
+    var resourceUriResolver = new ResourceUriResolver(resourceProvider);
+    var packageUriResolver = new PackageMapUriResolver(
+        resourceProvider, packageMapProvider.packageMap);
+    context.sourceFactory =
+        new SourceFactory([packageUriResolver, resourceUriResolver]);
+  }
 }
 
 class EchoHandler implements RequestHandler {
   @override
   Response handleRequest(Request request) {
     if (request.method == 'echo') {
       return new Response(request.id, result: {'echo': true});
     }
     return null;
   }
@@ skipping 10 matching lines @@
   _MockServerOperation(this.context);
 
   @override
   ServerOperationPriority get priority => ServerOperationPriority.ANALYSIS;
 
   @override
   void perform(AnalysisServer server) {
     isComplete = true;
   }
 }