OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| 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. |
| 4 |
| 5 library test.src.watch_manager_test; |
| 6 |
| 7 import 'dart:async'; |
| 8 |
| 9 import 'package:analysis_server/src/watch_manager.dart'; |
| 10 import 'package:analyzer/file_system/file_system.dart'; |
| 11 import 'package:analyzer/file_system/memory_file_system.dart'; |
| 12 import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| 13 import 'package:unittest/unittest.dart'; |
| 14 import 'package:watcher/watcher.dart'; |
| 15 |
| 16 import '../mocks.dart'; |
| 17 |
| 18 main() { |
| 19 groupSep = ' | '; |
| 20 defineReflectiveTests(WatchManagerTest); |
| 21 defineReflectiveTests(WatchNodeTest); |
| 22 } |
| 23 |
| 24 /** |
| 25 * Tokens that can be used for testing purposes. |
| 26 */ |
| 27 class Token { |
| 28 /** |
| 29 * A name used for debugging. |
| 30 */ |
| 31 final String name; |
| 32 |
| 33 /** |
| 34 * Initialize a newly created token to have the given name. |
| 35 */ |
| 36 Token(this.name); |
| 37 |
| 38 @override |
| 39 String toString() => name; |
| 40 } |
| 41 |
| 42 /** |
| 43 * A listener that captures the state of watch events so that they can be |
| 44 * tested. |
| 45 */ |
| 46 class WatchListener { |
| 47 /** |
| 48 * The event that was passed to the listener method. |
| 49 */ |
| 50 WatchEvent event; |
| 51 |
| 52 /** |
| 53 * The tokens that were passed to the listener method. |
| 54 */ |
| 55 List<Token> tokens; |
| 56 |
| 57 /** |
| 58 * The listener method. |
| 59 */ |
| 60 void handleWatchEvent(WatchEvent event, List<Token> tokens) { |
| 61 this.event = event; |
| 62 this.tokens = tokens; |
| 63 } |
| 64 } |
| 65 |
| 66 @reflectiveTest |
| 67 class WatchManagerTest { |
| 68 MemoryResourceProvider provider; |
| 69 WatchListener listener; |
| 70 WatchManager<Token> manager; |
| 71 |
| 72 void setUp() { |
| 73 provider = new MemoryResourceProvider(); |
| 74 listener = new WatchListener(); |
| 75 manager = new WatchManager<Token>(provider, listener.handleWatchEvent); |
| 76 } |
| 77 |
| 78 Future test_addFolder_folderAndSubfolder() async { |
| 79 Folder topFolder = provider.getFolder('/a/b'); |
| 80 Folder childFolder = provider.getFolder('/a/b/c/d'); |
| 81 Token topToken = new Token('topToken'); |
| 82 Token childToken = new Token('childToken'); |
| 83 manager.addFolder(topFolder, topToken); |
| 84 manager.addFolder(childFolder, childToken); |
| 85 |
| 86 File newFile1 = provider.newFile('/a/b/c/lib.dart', ''); |
| 87 await _expectEvent(ChangeType.ADD, newFile1.path, [topToken]); |
| 88 |
| 89 File newFile2 = provider.newFile('/a/b/c/d/lib.dart', ''); |
| 90 _expectEvent(ChangeType.ADD, newFile2.path, [topToken, childToken]); |
| 91 } |
| 92 |
| 93 Future test_addFolder_singleFolder_multipleTokens() { |
| 94 Folder folder = provider.getFolder('/a/b'); |
| 95 Token token1 = new Token('token1'); |
| 96 Token token2 = new Token('token2'); |
| 97 manager.addFolder(folder, token1); |
| 98 manager.addFolder(folder, token2); |
| 99 |
| 100 File newFile = provider.newFile('/a/b/lib.dart', ''); |
| 101 _expectEvent(ChangeType.ADD, newFile.path, [token1, token2]); |
| 102 } |
| 103 |
| 104 Future test_addFolder_singleFolder_singleToken() async { |
| 105 Folder folder = provider.getFolder('/a/b'); |
| 106 Token token = new Token('token'); |
| 107 manager.addFolder(folder, token); |
| 108 |
| 109 Folder newFolder = provider.newFolder('/a/b/c'); |
| 110 await _expectEvent(ChangeType.ADD, newFolder.path, [token]); |
| 111 |
| 112 File newFile = provider.newFile('/a/b/c/lib.dart', ''); |
| 113 _expectEvent(ChangeType.ADD, newFile.path, [token]); |
| 114 } |
| 115 |
| 116 Future test_addFolder_unrelatedFolders() async { |
| 117 Folder folder1 = provider.getFolder('/a/b'); |
| 118 Folder folder2 = provider.getFolder('/c/d'); |
| 119 Token token1 = new Token('token1'); |
| 120 Token token2 = new Token('token2'); |
| 121 manager.addFolder(folder1, token1); |
| 122 manager.addFolder(folder2, token2); |
| 123 |
| 124 File newFile1 = provider.newFile('/a/b/lib.dart', ''); |
| 125 await _expectEvent(ChangeType.ADD, newFile1.path, [token1]); |
| 126 |
| 127 File newFile2 = provider.newFile('/c/d/lib.dart', ''); |
| 128 _expectEvent(ChangeType.ADD, newFile2.path, [token2]); |
| 129 } |
| 130 |
| 131 void test_creation() { |
| 132 expect(manager, isNotNull); |
| 133 } |
| 134 |
| 135 Future test_removeFolder_multipleTokens() { |
| 136 Folder folder = provider.getFolder('/a/b'); |
| 137 Token token1 = new Token('token1'); |
| 138 Token token2 = new Token('token2'); |
| 139 manager.addFolder(folder, token1); |
| 140 manager.addFolder(folder, token2); |
| 141 manager.removeFolder(folder, token2); |
| 142 |
| 143 File newFile = provider.newFile('/a/b/lib.dart', ''); |
| 144 _expectEvent(ChangeType.ADD, newFile.path, [token1]); |
| 145 } |
| 146 |
| 147 Future test_removeFolder_unadded() { |
| 148 Folder folder = provider.getFolder('/a/b'); |
| 149 Token token = new Token('token'); |
| 150 manager.removeFolder(folder, token); |
| 151 |
| 152 provider.newFile('/a/b/lib.dart', ''); |
| 153 _expectNoEvent(); |
| 154 } |
| 155 |
| 156 Future test_removeFolder_withChildren() async { |
| 157 Folder topFolder = provider.getFolder('/a/b'); |
| 158 Folder childFolder = provider.getFolder('/a/b/c/d'); |
| 159 Token topToken = new Token('topToken'); |
| 160 Token childToken = new Token('childToken'); |
| 161 manager.addFolder(topFolder, topToken); |
| 162 manager.addFolder(childFolder, childToken); |
| 163 manager.removeFolder(topFolder, topToken); |
| 164 |
| 165 File newFile = provider.newFile('/a/b/c/d/lib.dart', ''); |
| 166 await _expectEvent(ChangeType.ADD, newFile.path, [childToken]); |
| 167 |
| 168 provider.newFile('/a/b/lib.dart', ''); |
| 169 _expectNoEvent(); |
| 170 } |
| 171 |
| 172 Future test_removeFolder_withNoChildren() { |
| 173 Folder folder = provider.getFolder('/a/b'); |
| 174 Token token = new Token('token'); |
| 175 manager.addFolder(folder, token); |
| 176 manager.removeFolder(folder, token); |
| 177 |
| 178 provider.newFile('/a/b/lib.dart', ''); |
| 179 _expectNoEvent(); |
| 180 } |
| 181 |
| 182 Future _expectEvent(ChangeType expectedType, String expectedPath, |
| 183 List<Token> expectedTokens) async { |
| 184 await pumpEventQueue(); |
| 185 WatchEvent event = listener.event; |
| 186 expect(event, isNotNull); |
| 187 expect(event.type, expectedType); |
| 188 expect(event.path, expectedPath); |
| 189 expect(listener.tokens, unorderedEquals(expectedTokens)); |
| 190 } |
| 191 |
| 192 Future _expectNoEvent() async { |
| 193 await pumpEventQueue(); |
| 194 expect(listener.event, isNull); |
| 195 expect(listener.tokens, isNull); |
| 196 } |
| 197 } |
| 198 |
| 199 @reflectiveTest |
| 200 class WatchNodeTest { |
| 201 MemoryResourceProvider provider = new MemoryResourceProvider(); |
| 202 |
| 203 void test_creation_folder() { |
| 204 Folder folder = provider.getFolder('/a/b'); |
| 205 WatchNode node = new WatchNode(folder); |
| 206 expect(node, isNotNull); |
| 207 expect(node.children, isEmpty); |
| 208 expect(node.folder, folder); |
| 209 expect(node.parent, isNull); |
| 210 expect(node.subscription, isNull); |
| 211 expect(node.tokens, isEmpty); |
| 212 } |
| 213 |
| 214 void test_creation_noFolder() { |
| 215 WatchNode node = new WatchNode(null); |
| 216 expect(node, isNotNull); |
| 217 expect(node.children, isEmpty); |
| 218 expect(node.folder, isNull); |
| 219 expect(node.parent, isNull); |
| 220 expect(node.subscription, isNull); |
| 221 expect(node.tokens, isEmpty); |
| 222 } |
| 223 |
| 224 void test_delete_nested_child() { |
| 225 WatchNode rootNode = new WatchNode(null); |
| 226 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 227 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 228 WatchNode grandchildNode = new WatchNode(provider.getFolder('/a/b/c/d/e')); |
| 229 rootNode.insert(topNode); |
| 230 rootNode.insert(childNode); |
| 231 rootNode.insert(grandchildNode); |
| 232 |
| 233 childNode.delete(); |
| 234 expect(rootNode.children, equals([topNode])); |
| 235 expect(topNode.children, equals([grandchildNode])); |
| 236 expect(topNode.parent, rootNode); |
| 237 expect(grandchildNode.parent, topNode); |
| 238 } |
| 239 |
| 240 void test_delete_nested_noChild() { |
| 241 WatchNode rootNode = new WatchNode(null); |
| 242 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 243 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 244 rootNode.insert(topNode); |
| 245 rootNode.insert(childNode); |
| 246 |
| 247 childNode.delete(); |
| 248 expect(rootNode.children, equals([topNode])); |
| 249 expect(topNode.children, isEmpty); |
| 250 expect(topNode.parent, rootNode); |
| 251 } |
| 252 |
| 253 void test_delete_top_child() { |
| 254 WatchNode rootNode = new WatchNode(null); |
| 255 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 256 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 257 rootNode.insert(topNode); |
| 258 rootNode.insert(childNode); |
| 259 |
| 260 topNode.delete(); |
| 261 expect(rootNode.children, equals([childNode])); |
| 262 expect(childNode.parent, rootNode); |
| 263 } |
| 264 |
| 265 void test_delete_top_noChild() { |
| 266 WatchNode rootNode = new WatchNode(null); |
| 267 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 268 rootNode.insert(topNode); |
| 269 |
| 270 topNode.delete(); |
| 271 expect(rootNode.children, isEmpty); |
| 272 } |
| 273 |
| 274 void test_findParent_childOfLeaf() { |
| 275 WatchNode rootNode = new WatchNode(null); |
| 276 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 277 rootNode.insert(topNode); |
| 278 |
| 279 expect(rootNode.findParent('/a/b/c'), topNode); |
| 280 } |
| 281 |
| 282 void test_findParent_childOfNonLeaf() { |
| 283 WatchNode rootNode = new WatchNode(null); |
| 284 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 285 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 286 rootNode.insert(topNode); |
| 287 rootNode.insert(childNode); |
| 288 |
| 289 expect(rootNode.findParent('/a/b/c'), topNode); |
| 290 } |
| 291 |
| 292 void test_findParent_noMatch() { |
| 293 WatchNode rootNode = new WatchNode(null); |
| 294 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 295 rootNode.insert(topNode); |
| 296 |
| 297 expect(rootNode.findParent('/c/d'), rootNode); |
| 298 } |
| 299 |
| 300 void test_insert_intermediate_afterParentAndChild() { |
| 301 WatchNode rootNode = new WatchNode(null); |
| 302 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 303 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 304 WatchNode intermediateNode = new WatchNode(provider.getFolder('/a/b/c')); |
| 305 |
| 306 rootNode.insert(topNode); |
| 307 rootNode.insert(childNode); |
| 308 rootNode.insert(intermediateNode); |
| 309 expect(topNode.parent, rootNode); |
| 310 expect(topNode.children, equals([intermediateNode])); |
| 311 expect(intermediateNode.parent, topNode); |
| 312 expect(intermediateNode.children, equals([childNode])); |
| 313 expect(childNode.parent, intermediateNode); |
| 314 expect(childNode.children, isEmpty); |
| 315 } |
| 316 |
| 317 void test_insert_nested_afterParent() { |
| 318 WatchNode rootNode = new WatchNode(null); |
| 319 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 320 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 321 |
| 322 rootNode.insert(topNode); |
| 323 rootNode.insert(childNode); |
| 324 expect(childNode.parent, topNode); |
| 325 expect(childNode.children, isEmpty); |
| 326 expect(topNode.children, equals([childNode])); |
| 327 } |
| 328 |
| 329 void test_insert_nested_beforeParent() { |
| 330 WatchNode rootNode = new WatchNode(null); |
| 331 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 332 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 333 |
| 334 rootNode.insert(childNode); |
| 335 rootNode.insert(topNode); |
| 336 expect(childNode.parent, topNode); |
| 337 expect(childNode.children, isEmpty); |
| 338 expect(topNode.children, equals([childNode])); |
| 339 } |
| 340 |
| 341 void test_insert_top() { |
| 342 WatchNode rootNode = new WatchNode(null); |
| 343 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 344 |
| 345 rootNode.insert(topNode); |
| 346 expect(rootNode.children, equals([topNode])); |
| 347 expect(topNode.parent, rootNode); |
| 348 expect(topNode.children, isEmpty); |
| 349 } |
| 350 } |
OLD | NEW |