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 * Clear the state so that we can distinguish between not receiving an event |
| 59 * and receiving the wrong event. |
| 60 */ |
| 61 void clear() { |
| 62 this.event = null; |
| 63 this.tokens = null; |
| 64 } |
| 65 |
| 66 /** |
| 67 * The listener method. |
| 68 */ |
| 69 void handleWatchEvent(WatchEvent event, List<Token> tokens) { |
| 70 this.event = event; |
| 71 this.tokens = tokens; |
| 72 } |
| 73 } |
| 74 |
| 75 @reflectiveTest |
| 76 class WatchManagerTest { |
| 77 MemoryResourceProvider provider; |
| 78 WatchListener listener; |
| 79 WatchManager<Token> manager; |
| 80 |
| 81 void setUp() { |
| 82 provider = new MemoryResourceProvider(); |
| 83 listener = new WatchListener(); |
| 84 manager = new WatchManager<Token>(provider, listener.handleWatchEvent); |
| 85 } |
| 86 |
| 87 Future test_addFolder_folderAndSubfolder() async { |
| 88 Folder topFolder = provider.getFolder('/a/b'); |
| 89 Folder childFolder = provider.getFolder('/a/b/c/d'); |
| 90 Token topToken = new Token('topToken'); |
| 91 Token childToken = new Token('childToken'); |
| 92 manager.addFolder(topFolder, topToken); |
| 93 manager.addFolder(childFolder, childToken); |
| 94 |
| 95 File newFile1 = provider.newFile('/a/b/c/lib.dart', ''); |
| 96 await _expectEvent(ChangeType.ADD, newFile1.path, [topToken]); |
| 97 |
| 98 File newFile2 = provider.newFile('/a/b/c/d/lib.dart', ''); |
| 99 _expectEvent(ChangeType.ADD, newFile2.path, [topToken, childToken]); |
| 100 } |
| 101 |
| 102 Future test_addFolder_singleFolder_multipleTokens() { |
| 103 Folder folder = provider.getFolder('/a/b'); |
| 104 Token token1 = new Token('token1'); |
| 105 Token token2 = new Token('token2'); |
| 106 manager.addFolder(folder, token1); |
| 107 manager.addFolder(folder, token2); |
| 108 |
| 109 File newFile = provider.newFile('/a/b/lib.dart', ''); |
| 110 return _expectEvent(ChangeType.ADD, newFile.path, [token1, token2]); |
| 111 } |
| 112 |
| 113 Future test_addFolder_singleFolder_singleToken() async { |
| 114 Folder folder = provider.getFolder('/a/b'); |
| 115 Token token = new Token('token'); |
| 116 manager.addFolder(folder, token); |
| 117 |
| 118 Folder newFolder = provider.newFolder('/a/b/c'); |
| 119 await _expectEvent(ChangeType.ADD, newFolder.path, [token]); |
| 120 |
| 121 File newFile = provider.newFile('/a/b/c/lib.dart', ''); |
| 122 _expectEvent(ChangeType.ADD, newFile.path, [token]); |
| 123 } |
| 124 |
| 125 Future test_addFolder_unrelatedFolders() async { |
| 126 Folder folder1 = provider.getFolder('/a/b'); |
| 127 Folder folder2 = provider.getFolder('/c/d'); |
| 128 Token token1 = new Token('token1'); |
| 129 Token token2 = new Token('token2'); |
| 130 manager.addFolder(folder1, token1); |
| 131 manager.addFolder(folder2, token2); |
| 132 |
| 133 File newFile1 = provider.newFile('/a/b/lib.dart', ''); |
| 134 await _expectEvent(ChangeType.ADD, newFile1.path, [token1]); |
| 135 |
| 136 File newFile2 = provider.newFile('/c/d/lib.dart', ''); |
| 137 _expectEvent(ChangeType.ADD, newFile2.path, [token2]); |
| 138 } |
| 139 |
| 140 void test_creation() { |
| 141 expect(manager, isNotNull); |
| 142 } |
| 143 |
| 144 Future test_removeFolder_multipleTokens() { |
| 145 Folder folder = provider.getFolder('/a/b'); |
| 146 Token token1 = new Token('token1'); |
| 147 Token token2 = new Token('token2'); |
| 148 manager.addFolder(folder, token1); |
| 149 manager.addFolder(folder, token2); |
| 150 manager.removeFolder(folder, token2); |
| 151 |
| 152 File newFile = provider.newFile('/a/b/lib.dart', ''); |
| 153 return _expectEvent(ChangeType.ADD, newFile.path, [token1]); |
| 154 } |
| 155 |
| 156 Future test_removeFolder_unadded() { |
| 157 Folder folder = provider.getFolder('/a/b'); |
| 158 Token token = new Token('token'); |
| 159 expect(() => manager.removeFolder(folder, token), throws); |
| 160 |
| 161 provider.newFile('/a/b/lib.dart', ''); |
| 162 return _expectNoEvent(); |
| 163 } |
| 164 |
| 165 Future test_removeFolder_withChildren() async { |
| 166 Folder topFolder = provider.getFolder('/a/b'); |
| 167 Folder childFolder = provider.getFolder('/a/b/c/d'); |
| 168 Token topToken = new Token('topToken'); |
| 169 Token childToken = new Token('childToken'); |
| 170 manager.addFolder(topFolder, topToken); |
| 171 manager.addFolder(childFolder, childToken); |
| 172 manager.removeFolder(topFolder, topToken); |
| 173 |
| 174 File newFile = provider.newFile('/a/b/c/d/lib.dart', ''); |
| 175 await _expectEvent(ChangeType.ADD, newFile.path, [childToken]); |
| 176 |
| 177 provider.newFile('/a/b/lib.dart', ''); |
| 178 _expectNoEvent(); |
| 179 } |
| 180 |
| 181 Future test_removeFolder_withNoChildren() { |
| 182 Folder folder = provider.getFolder('/a/b'); |
| 183 Token token = new Token('token'); |
| 184 manager.addFolder(folder, token); |
| 185 manager.removeFolder(folder, token); |
| 186 |
| 187 provider.newFile('/a/b/lib.dart', ''); |
| 188 return _expectNoEvent(); |
| 189 } |
| 190 |
| 191 Future _expectEvent(ChangeType expectedType, String expectedPath, |
| 192 List<Token> expectedTokens) async { |
| 193 await pumpEventQueue(); |
| 194 WatchEvent event = listener.event; |
| 195 expect(event, isNotNull); |
| 196 expect(event.type, expectedType); |
| 197 expect(event.path, expectedPath); |
| 198 expect(listener.tokens, unorderedEquals(expectedTokens)); |
| 199 listener.clear(); |
| 200 } |
| 201 |
| 202 Future _expectNoEvent() async { |
| 203 await pumpEventQueue(); |
| 204 expect(listener.event, isNull); |
| 205 expect(listener.tokens, isNull); |
| 206 } |
| 207 } |
| 208 |
| 209 @reflectiveTest |
| 210 class WatchNodeTest { |
| 211 MemoryResourceProvider provider = new MemoryResourceProvider(); |
| 212 |
| 213 void test_creation_folder() { |
| 214 Folder folder = provider.getFolder('/a/b'); |
| 215 WatchNode node = new WatchNode(folder); |
| 216 expect(node, isNotNull); |
| 217 expect(node.children, isEmpty); |
| 218 expect(node.folder, folder); |
| 219 expect(node.parent, isNull); |
| 220 expect(node.subscription, isNull); |
| 221 expect(node.tokens, isEmpty); |
| 222 } |
| 223 |
| 224 void test_creation_noFolder() { |
| 225 WatchNode node = new WatchNode(null); |
| 226 expect(node, isNotNull); |
| 227 expect(node.children, isEmpty); |
| 228 expect(node.folder, isNull); |
| 229 expect(node.parent, isNull); |
| 230 expect(node.subscription, isNull); |
| 231 expect(node.tokens, isEmpty); |
| 232 } |
| 233 |
| 234 void test_delete_nested_child() { |
| 235 WatchNode rootNode = new WatchNode(null); |
| 236 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 237 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 238 WatchNode grandchildNode = new WatchNode(provider.getFolder('/a/b/c/d/e')); |
| 239 rootNode.insert(topNode); |
| 240 rootNode.insert(childNode); |
| 241 rootNode.insert(grandchildNode); |
| 242 |
| 243 childNode.delete(); |
| 244 expect(rootNode.children, equals([topNode])); |
| 245 expect(topNode.children, equals([grandchildNode])); |
| 246 expect(topNode.parent, rootNode); |
| 247 expect(grandchildNode.parent, topNode); |
| 248 } |
| 249 |
| 250 void test_delete_nested_noChild() { |
| 251 WatchNode rootNode = new WatchNode(null); |
| 252 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 253 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 254 rootNode.insert(topNode); |
| 255 rootNode.insert(childNode); |
| 256 |
| 257 childNode.delete(); |
| 258 expect(rootNode.children, equals([topNode])); |
| 259 expect(topNode.children, isEmpty); |
| 260 expect(topNode.parent, rootNode); |
| 261 } |
| 262 |
| 263 void test_delete_top_child() { |
| 264 WatchNode rootNode = new WatchNode(null); |
| 265 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 266 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 267 rootNode.insert(topNode); |
| 268 rootNode.insert(childNode); |
| 269 |
| 270 topNode.delete(); |
| 271 expect(rootNode.children, equals([childNode])); |
| 272 expect(childNode.parent, rootNode); |
| 273 } |
| 274 |
| 275 void test_delete_top_noChild() { |
| 276 WatchNode rootNode = new WatchNode(null); |
| 277 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 278 rootNode.insert(topNode); |
| 279 |
| 280 topNode.delete(); |
| 281 expect(rootNode.children, isEmpty); |
| 282 } |
| 283 |
| 284 void test_findParent_childOfLeaf() { |
| 285 WatchNode rootNode = new WatchNode(null); |
| 286 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 287 rootNode.insert(topNode); |
| 288 |
| 289 expect(rootNode.findParent('/a/b/c'), topNode); |
| 290 } |
| 291 |
| 292 void test_findParent_childOfNonLeaf() { |
| 293 WatchNode rootNode = new WatchNode(null); |
| 294 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 295 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 296 rootNode.insert(topNode); |
| 297 rootNode.insert(childNode); |
| 298 |
| 299 expect(rootNode.findParent('/a/b/c'), topNode); |
| 300 } |
| 301 |
| 302 void test_findParent_noMatch() { |
| 303 WatchNode rootNode = new WatchNode(null); |
| 304 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 305 rootNode.insert(topNode); |
| 306 |
| 307 expect(rootNode.findParent('/c/d'), rootNode); |
| 308 } |
| 309 |
| 310 void test_insert_intermediate_afterParentAndChild() { |
| 311 WatchNode rootNode = new WatchNode(null); |
| 312 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 313 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 314 WatchNode intermediateNode = new WatchNode(provider.getFolder('/a/b/c')); |
| 315 |
| 316 rootNode.insert(topNode); |
| 317 rootNode.insert(childNode); |
| 318 rootNode.insert(intermediateNode); |
| 319 expect(topNode.parent, rootNode); |
| 320 expect(topNode.children, equals([intermediateNode])); |
| 321 expect(intermediateNode.parent, topNode); |
| 322 expect(intermediateNode.children, equals([childNode])); |
| 323 expect(childNode.parent, intermediateNode); |
| 324 expect(childNode.children, isEmpty); |
| 325 } |
| 326 |
| 327 void test_insert_nested_afterParent() { |
| 328 WatchNode rootNode = new WatchNode(null); |
| 329 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 330 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 331 |
| 332 rootNode.insert(topNode); |
| 333 rootNode.insert(childNode); |
| 334 expect(childNode.parent, topNode); |
| 335 expect(childNode.children, isEmpty); |
| 336 expect(topNode.children, equals([childNode])); |
| 337 } |
| 338 |
| 339 void test_insert_nested_beforeParent() { |
| 340 WatchNode rootNode = new WatchNode(null); |
| 341 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 342 WatchNode childNode = new WatchNode(provider.getFolder('/a/b/c/d')); |
| 343 |
| 344 rootNode.insert(childNode); |
| 345 rootNode.insert(topNode); |
| 346 expect(childNode.parent, topNode); |
| 347 expect(childNode.children, isEmpty); |
| 348 expect(topNode.children, equals([childNode])); |
| 349 } |
| 350 |
| 351 void test_insert_top() { |
| 352 WatchNode rootNode = new WatchNode(null); |
| 353 WatchNode topNode = new WatchNode(provider.getFolder('/a/b')); |
| 354 |
| 355 rootNode.insert(topNode); |
| 356 expect(rootNode.children, equals([topNode])); |
| 357 expect(topNode.parent, rootNode); |
| 358 expect(topNode.children, isEmpty); |
| 359 } |
| 360 } |
OLD | NEW |