OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library test.package.map.provider; | 5 library test.package.map.provider; |
6 | 6 |
7 import 'package:analyzer/file_system/file_system.dart'; | 7 import 'package:analyzer/file_system/file_system.dart'; |
8 import 'package:analyzer/file_system/memory_file_system.dart'; | 8 import 'package:analyzer/file_system/memory_file_system.dart'; |
9 import 'package:analyzer/source/package_map_provider.dart'; | 9 import 'package:analyzer/source/package_map_provider.dart'; |
10 import 'package:analyzer/source/pub_package_map_provider.dart'; | 10 import 'package:analyzer/source/pub_package_map_provider.dart'; |
| 11 import 'package:analyzer/src/generated/sdk.dart'; |
11 import 'package:analyzer/src/generated/sdk_io.dart'; | 12 import 'package:analyzer/src/generated/sdk_io.dart'; |
12 import 'package:unittest/unittest.dart'; | 13 import 'package:unittest/unittest.dart'; |
13 | 14 |
| 15 import '../reflective_tests.dart'; |
14 import '../utils.dart'; | 16 import '../utils.dart'; |
15 | 17 |
16 main() { | 18 main() { |
17 initializeTestEnvironment(); | 19 initializeTestEnvironment(); |
| 20 runReflectiveTests(PubPackageMapProviderTest); |
| 21 } |
18 | 22 |
19 group('PubPackageMapProvider', () { | 23 @reflectiveTest |
20 group('parsePackageMap', () { | 24 class PubPackageMapProviderTest { |
21 MemoryResourceProvider resourceProvider; | 25 static const String projectPath = '/path/to/project'; |
22 PubPackageMapProvider packageMapProvider; | |
23 const String projectPath = '/path/to/project'; | |
24 Folder projectFolder; | |
25 | 26 |
26 setUp(() { | 27 DartSdk sdk = DirectoryBasedDartSdk.defaultSdk; |
27 resourceProvider = new MemoryResourceProvider(); | 28 MemoryResourceProvider resourceProvider; |
28 packageMapProvider = new PubPackageMapProvider( | 29 PubPackageMapProvider packageMapProvider; |
29 resourceProvider, DirectoryBasedDartSdk.defaultSdk); | 30 Folder projectFolder; |
30 projectFolder = resourceProvider.newFolder(projectPath); | |
31 }); | |
32 | 31 |
33 PackageMapInfo parsePackageMap(Object obj) { | 32 PackageMapInfo parsePackageMap(Map obj) { |
34 return packageMapProvider.parsePackageMap(obj, projectFolder); | 33 return packageMapProvider.parsePackageMap(obj, projectFolder); |
| 34 } |
| 35 |
| 36 void setUp() { |
| 37 resourceProvider = new MemoryResourceProvider(); |
| 38 packageMapProvider = new PubPackageMapProvider(resourceProvider, sdk); |
| 39 projectFolder = resourceProvider.newFolder(projectPath); |
| 40 } |
| 41 |
| 42 void test_computePackageMap_noLockFile() { |
| 43 packageMapProvider = |
| 44 new PubPackageMapProvider(resourceProvider, sdk, (Folder folder) { |
| 45 fail('Unexpected "pub list" invocation'); |
| 46 }); |
| 47 PackageMapInfo info = packageMapProvider.computePackageMap(projectFolder); |
| 48 expect(info.packageMap, isNull); |
| 49 expect(info.dependencies, unorderedEquals(['$projectPath/pubspec.lock'])); |
| 50 } |
| 51 |
| 52 void test_parsePackageMap_dontIgnoreNonExistingFolder() { |
| 53 String packageName = 'foo'; |
| 54 String folderPath = '/path/to/folder'; |
| 55 Map<String, List<Folder>> result = parsePackageMap({ |
| 56 'packages': {packageName: folderPath} |
| 57 }).packageMap; |
| 58 expect(result, hasLength(1)); |
| 59 expect(result.keys, contains(packageName)); |
| 60 expect(result[packageName], hasLength(1)); |
| 61 expect(result[packageName][0], new isInstanceOf<Folder>()); |
| 62 expect(result[packageName][0].path, equals(folderPath)); |
| 63 } |
| 64 |
| 65 void test_parsePackageMap_handleDependencies() { |
| 66 String path1 = '/path/to/folder1/pubspec.lock'; |
| 67 String path2 = '/path/to/folder2/pubspec.lock'; |
| 68 resourceProvider.newFile(path1, '...'); |
| 69 resourceProvider.newFile(path2, '...'); |
| 70 Set<String> dependencies = parsePackageMap({ |
| 71 'packages': {}, |
| 72 'input_files': [path1, path2] |
| 73 }).dependencies; |
| 74 expect(dependencies, hasLength(2)); |
| 75 expect(dependencies, contains(path1)); |
| 76 expect(dependencies, contains(path2)); |
| 77 } |
| 78 |
| 79 void test_parsePackageMap_normalFolder() { |
| 80 String packageName = 'foo'; |
| 81 String folderPath = '/path/to/folder'; |
| 82 resourceProvider.newFolder(folderPath); |
| 83 Map<String, List<Folder>> result = parsePackageMap({ |
| 84 'packages': {packageName: folderPath} |
| 85 }).packageMap; |
| 86 expect(result, hasLength(1)); |
| 87 expect(result.keys, contains(packageName)); |
| 88 expect(result[packageName], hasLength(1)); |
| 89 expect(result[packageName][0], new isInstanceOf<Folder>()); |
| 90 expect(result[packageName][0].path, equals(folderPath)); |
| 91 } |
| 92 |
| 93 void test_parsePackageMap_packageMapsToList() { |
| 94 String packageName = 'foo'; |
| 95 String folderPath1 = '/path/to/folder1'; |
| 96 String folderPath2 = '/path/to/folder2'; |
| 97 resourceProvider.newFolder(folderPath1); |
| 98 resourceProvider.newFolder(folderPath2); |
| 99 Map<String, List<Folder>> result = parsePackageMap({ |
| 100 'packages': { |
| 101 packageName: [folderPath1, folderPath2] |
35 } | 102 } |
| 103 }).packageMap; |
| 104 expect(result, hasLength(1)); |
| 105 expect(result.keys, contains(packageName)); |
| 106 expect(result[packageName], hasLength(2)); |
| 107 for (int i = 0; i < 2; i++) { |
| 108 expect(result[packageName][i], new isInstanceOf<Folder>()); |
| 109 expect(result[packageName][i].path, isIn([folderPath1, folderPath2])); |
| 110 } |
| 111 } |
36 | 112 |
37 test('normal folder', () { | 113 void test_parsePackageMap_relativePahInPackages() { |
38 String packageName = 'foo'; | 114 String packagePath = '/path/to/package'; |
39 String folderPath = '/path/to/folder'; | 115 String relativePackagePath = '../package'; |
40 resourceProvider.newFolder(folderPath); | 116 String packageName = 'foo'; |
41 Map<String, List<Folder>> result = parsePackageMap({ | 117 resourceProvider.newFolder(projectPath); |
42 'packages': {packageName: folderPath} | 118 resourceProvider.newFolder(packagePath); |
43 }).packageMap; | 119 Map<String, List<Folder>> result = parsePackageMap({ |
44 expect(result, hasLength(1)); | 120 'packages': { |
45 expect(result.keys, contains(packageName)); | 121 packageName: [relativePackagePath] |
46 expect(result[packageName], hasLength(1)); | 122 } |
47 expect(result[packageName][0], new isInstanceOf<Folder>()); | 123 }).packageMap; |
48 expect(result[packageName][0].path, equals(folderPath)); | 124 expect(result[packageName][0].path, equals(packagePath)); |
49 }); | 125 } |
50 | 126 |
51 test("don't ignore nonexistent folder", () { | 127 void test_parsePackageMap_relativePathInDependencies() { |
52 String packageName = 'foo'; | 128 String dependencyPath = '/path/to/pubspec.lock'; |
53 String folderPath = '/path/to/folder'; | 129 String relativeDependencyPath = '../pubspec.lock'; |
54 Map<String, List<Folder>> result = parsePackageMap({ | 130 resourceProvider.newFolder(projectPath); |
55 'packages': {packageName: folderPath} | 131 resourceProvider.newFile(dependencyPath, 'contents'); |
56 }).packageMap; | 132 Set<String> dependencies = parsePackageMap({ |
57 expect(result, hasLength(1)); | 133 'packages': {}, |
58 expect(result.keys, contains(packageName)); | 134 'input_files': [relativeDependencyPath] |
59 expect(result[packageName], hasLength(1)); | 135 }).dependencies; |
60 expect(result[packageName][0], new isInstanceOf<Folder>()); | 136 expect(dependencies, hasLength(1)); |
61 expect(result[packageName][0].path, equals(folderPath)); | 137 expect(dependencies, contains(dependencyPath)); |
62 }); | 138 } |
63 | |
64 test('package maps to list', () { | |
65 String packageName = 'foo'; | |
66 String folderPath1 = '/path/to/folder1'; | |
67 String folderPath2 = '/path/to/folder2'; | |
68 resourceProvider.newFolder(folderPath1); | |
69 resourceProvider.newFolder(folderPath2); | |
70 Map<String, List<Folder>> result = parsePackageMap({ | |
71 'packages': { | |
72 packageName: [folderPath1, folderPath2] | |
73 } | |
74 }).packageMap; | |
75 expect(result, hasLength(1)); | |
76 expect(result.keys, contains(packageName)); | |
77 expect(result[packageName], hasLength(2)); | |
78 for (int i = 0; i < 2; i++) { | |
79 expect(result[packageName][i], new isInstanceOf<Folder>()); | |
80 expect(result[packageName][i].path, isIn([folderPath1, folderPath2])); | |
81 } | |
82 }); | |
83 | |
84 test('Handle dependencies', () { | |
85 String path1 = '/path/to/folder1/pubspec.lock'; | |
86 String path2 = '/path/to/folder2/pubspec.lock'; | |
87 resourceProvider.newFile(path1, '...'); | |
88 resourceProvider.newFile(path2, '...'); | |
89 Set<String> dependencies = parsePackageMap({ | |
90 'packages': {}, | |
91 'input_files': [path1, path2] | |
92 }).dependencies; | |
93 expect(dependencies, hasLength(2)); | |
94 expect(dependencies, contains(path1)); | |
95 expect(dependencies, contains(path2)); | |
96 }); | |
97 | |
98 test('Relative path in packages', () { | |
99 String packagePath = '/path/to/package'; | |
100 String relativePackagePath = '../package'; | |
101 String packageName = 'foo'; | |
102 resourceProvider.newFolder(projectPath); | |
103 resourceProvider.newFolder(packagePath); | |
104 Map<String, List<Folder>> result = parsePackageMap({ | |
105 'packages': { | |
106 packageName: [relativePackagePath] | |
107 } | |
108 }).packageMap; | |
109 expect(result[packageName][0].path, equals(packagePath)); | |
110 }); | |
111 | |
112 test('Relative path in dependencies', () { | |
113 String dependencyPath = '/path/to/pubspec.lock'; | |
114 String relativeDependencyPath = '../pubspec.lock'; | |
115 resourceProvider.newFolder(projectPath); | |
116 resourceProvider.newFile(dependencyPath, 'contents'); | |
117 Set<String> dependencies = parsePackageMap({ | |
118 'packages': {}, | |
119 'input_files': [relativeDependencyPath] | |
120 }).dependencies; | |
121 expect(dependencies, hasLength(1)); | |
122 expect(dependencies, contains(dependencyPath)); | |
123 }); | |
124 }); | |
125 }); | |
126 } | 139 } |
OLD | NEW |