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_io.dart'; | 11 import 'package:analyzer/src/generated/sdk_io.dart'; |
12 import 'package:unittest/unittest.dart'; | 12 import 'package:unittest/unittest.dart'; |
13 | 13 |
| 14 import '../utils.dart'; |
| 15 |
14 main() { | 16 main() { |
15 groupSep = ' | '; | 17 initializeTestEnvironment(); |
16 | 18 |
17 group('PubPackageMapProvider', () { | 19 group('PubPackageMapProvider', () { |
18 group('parsePackageMap', () { | 20 group('parsePackageMap', () { |
19 MemoryResourceProvider resourceProvider; | 21 MemoryResourceProvider resourceProvider; |
20 PubPackageMapProvider packageMapProvider; | 22 PubPackageMapProvider packageMapProvider; |
21 const String projectPath = '/path/to/project'; | 23 const String projectPath = '/path/to/project'; |
22 Folder projectFolder; | 24 Folder projectFolder; |
23 | 25 |
24 setUp(() { | 26 setUp(() { |
25 resourceProvider = new MemoryResourceProvider(); | 27 resourceProvider = new MemoryResourceProvider(); |
26 packageMapProvider = new PubPackageMapProvider( | 28 packageMapProvider = new PubPackageMapProvider( |
27 resourceProvider, DirectoryBasedDartSdk.defaultSdk); | 29 resourceProvider, DirectoryBasedDartSdk.defaultSdk); |
28 projectFolder = resourceProvider.newFolder(projectPath); | 30 projectFolder = resourceProvider.newFolder(projectPath); |
29 }); | 31 }); |
30 | 32 |
31 PackageMapInfo parsePackageMap(Object obj) { | 33 PackageMapInfo parsePackageMap(Object obj) { |
32 return packageMapProvider.parsePackageMap(obj, projectFolder); | 34 return packageMapProvider.parsePackageMap(obj, projectFolder); |
33 } | 35 } |
34 | 36 |
35 test('normal folder', () { | 37 test('normal folder', () { |
36 String packageName = 'foo'; | 38 String packageName = 'foo'; |
37 String folderPath = '/path/to/folder'; | 39 String folderPath = '/path/to/folder'; |
38 resourceProvider.newFolder(folderPath); | 40 resourceProvider.newFolder(folderPath); |
39 Map<String, List<Folder>> result = | 41 Map<String, List<Folder>> result = parsePackageMap({ |
40 parsePackageMap({'packages': {packageName: folderPath}}).packageMap; | 42 'packages': {packageName: folderPath} |
| 43 }).packageMap; |
41 expect(result, hasLength(1)); | 44 expect(result, hasLength(1)); |
42 expect(result.keys, contains(packageName)); | 45 expect(result.keys, contains(packageName)); |
43 expect(result[packageName], hasLength(1)); | 46 expect(result[packageName], hasLength(1)); |
44 expect(result[packageName][0], new isInstanceOf<Folder>()); | 47 expect(result[packageName][0], new isInstanceOf<Folder>()); |
45 expect(result[packageName][0].path, equals(folderPath)); | 48 expect(result[packageName][0].path, equals(folderPath)); |
46 }); | 49 }); |
47 | 50 |
48 test("don't ignore nonexistent folder", () { | 51 test("don't ignore nonexistent folder", () { |
49 String packageName = 'foo'; | 52 String packageName = 'foo'; |
50 String folderPath = '/path/to/folder'; | 53 String folderPath = '/path/to/folder'; |
51 Map<String, List<Folder>> result = | 54 Map<String, List<Folder>> result = parsePackageMap({ |
52 parsePackageMap({'packages': {packageName: folderPath}}).packageMap; | 55 'packages': {packageName: folderPath} |
| 56 }).packageMap; |
53 expect(result, hasLength(1)); | 57 expect(result, hasLength(1)); |
54 expect(result.keys, contains(packageName)); | 58 expect(result.keys, contains(packageName)); |
55 expect(result[packageName], hasLength(1)); | 59 expect(result[packageName], hasLength(1)); |
56 expect(result[packageName][0], new isInstanceOf<Folder>()); | 60 expect(result[packageName][0], new isInstanceOf<Folder>()); |
57 expect(result[packageName][0].path, equals(folderPath)); | 61 expect(result[packageName][0].path, equals(folderPath)); |
58 }); | 62 }); |
59 | 63 |
60 test('package maps to list', () { | 64 test('package maps to list', () { |
61 String packageName = 'foo'; | 65 String packageName = 'foo'; |
62 String folderPath1 = '/path/to/folder1'; | 66 String folderPath1 = '/path/to/folder1'; |
63 String folderPath2 = '/path/to/folder2'; | 67 String folderPath2 = '/path/to/folder2'; |
64 resourceProvider.newFolder(folderPath1); | 68 resourceProvider.newFolder(folderPath1); |
65 resourceProvider.newFolder(folderPath2); | 69 resourceProvider.newFolder(folderPath2); |
66 Map<String, List<Folder>> result = parsePackageMap( | 70 Map<String, List<Folder>> result = parsePackageMap({ |
67 {'packages': {packageName: [folderPath1, folderPath2]}}).packageMap; | 71 'packages': { |
| 72 packageName: [folderPath1, folderPath2] |
| 73 } |
| 74 }).packageMap; |
68 expect(result, hasLength(1)); | 75 expect(result, hasLength(1)); |
69 expect(result.keys, contains(packageName)); | 76 expect(result.keys, contains(packageName)); |
70 expect(result[packageName], hasLength(2)); | 77 expect(result[packageName], hasLength(2)); |
71 for (int i = 0; i < 2; i++) { | 78 for (int i = 0; i < 2; i++) { |
72 expect(result[packageName][i], new isInstanceOf<Folder>()); | 79 expect(result[packageName][i], new isInstanceOf<Folder>()); |
73 expect(result[packageName][i].path, isIn([folderPath1, folderPath2])); | 80 expect(result[packageName][i].path, isIn([folderPath1, folderPath2])); |
74 } | 81 } |
75 }); | 82 }); |
76 | 83 |
77 test('Handle dependencies', () { | 84 test('Handle dependencies', () { |
78 String path1 = '/path/to/folder1/pubspec.lock'; | 85 String path1 = '/path/to/folder1/pubspec.lock'; |
79 String path2 = '/path/to/folder2/pubspec.lock'; | 86 String path2 = '/path/to/folder2/pubspec.lock'; |
80 resourceProvider.newFile(path1, '...'); | 87 resourceProvider.newFile(path1, '...'); |
81 resourceProvider.newFile(path2, '...'); | 88 resourceProvider.newFile(path2, '...'); |
82 Set<String> dependencies = parsePackageMap( | 89 Set<String> dependencies = parsePackageMap({ |
83 {'packages': {}, 'input_files': [path1, path2]}).dependencies; | 90 'packages': {}, |
| 91 'input_files': [path1, path2] |
| 92 }).dependencies; |
84 expect(dependencies, hasLength(2)); | 93 expect(dependencies, hasLength(2)); |
85 expect(dependencies, contains(path1)); | 94 expect(dependencies, contains(path1)); |
86 expect(dependencies, contains(path2)); | 95 expect(dependencies, contains(path2)); |
87 }); | 96 }); |
88 | 97 |
89 test('Relative path in packages', () { | 98 test('Relative path in packages', () { |
90 String packagePath = '/path/to/package'; | 99 String packagePath = '/path/to/package'; |
91 String relativePackagePath = '../package'; | 100 String relativePackagePath = '../package'; |
92 String packageName = 'foo'; | 101 String packageName = 'foo'; |
93 resourceProvider.newFolder(projectPath); | 102 resourceProvider.newFolder(projectPath); |
94 resourceProvider.newFolder(packagePath); | 103 resourceProvider.newFolder(packagePath); |
95 Map<String, List<Folder>> result = parsePackageMap( | 104 Map<String, List<Folder>> result = parsePackageMap({ |
96 {'packages': {packageName: [relativePackagePath]}}).packageMap; | 105 'packages': { |
| 106 packageName: [relativePackagePath] |
| 107 } |
| 108 }).packageMap; |
97 expect(result[packageName][0].path, equals(packagePath)); | 109 expect(result[packageName][0].path, equals(packagePath)); |
98 }); | 110 }); |
99 | 111 |
100 test('Relative path in dependencies', () { | 112 test('Relative path in dependencies', () { |
101 String dependencyPath = '/path/to/pubspec.lock'; | 113 String dependencyPath = '/path/to/pubspec.lock'; |
102 String relativeDependencyPath = '../pubspec.lock'; | 114 String relativeDependencyPath = '../pubspec.lock'; |
103 resourceProvider.newFolder(projectPath); | 115 resourceProvider.newFolder(projectPath); |
104 resourceProvider.newFile(dependencyPath, 'contents'); | 116 resourceProvider.newFile(dependencyPath, 'contents'); |
105 Set<String> dependencies = parsePackageMap({ | 117 Set<String> dependencies = parsePackageMap({ |
106 'packages': {}, | 118 'packages': {}, |
107 'input_files': [relativeDependencyPath] | 119 'input_files': [relativeDependencyPath] |
108 }).dependencies; | 120 }).dependencies; |
109 expect(dependencies, hasLength(1)); | 121 expect(dependencies, hasLength(1)); |
110 expect(dependencies, contains(dependencyPath)); | 122 expect(dependencies, contains(dependencyPath)); |
111 }); | 123 }); |
112 }); | 124 }); |
113 }); | 125 }); |
114 } | 126 } |
OLD | NEW |