Handle watching a non-existent directory.

pkg/watcher/test/utils.dart

 // Copyright (c) 2012, 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 watcher.test.utils;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
@@ skipping 58 matching lines @@
     _mockFileModificationTimes = null;
     mockGetModificationTime(null);
   }, "delete sandbox");
 }
 
 /// Creates a new [DirectoryWatcher] that watches a temporary directory.
 ///
 /// Normally, this will pause the schedule until the watcher is done scanning
 /// and is polling for changes. If you pass `false` for [waitForReady], it will
 /// not schedule this delay.
-DirectoryWatcher createWatcher({bool waitForReady}) {
+///
+/// If [dir] is provided, watches a subdirectory in the sandbox with that name.
+DirectoryWatcher createWatcher({String dir, bool waitForReady}) {
+  if (dir == null) {
+    dir = _sandboxDir;
+  } else {
+    dir = p.join(_sandboxDir, dir);
+  }
+
   // Use a short delay to make the tests run quickly.
-  _watcher = new DirectoryWatcher(_sandboxDir,
+  _watcher = new DirectoryWatcher(dir,
       pollingDelay: new Duration(milliseconds: 100));
 
   // Wait until the scan is finished so that we don't miss changes to files
   // that could occur before the scan completes.
   if (waitForReady != false) {
     schedule(() => _watcher.ready, "wait for watcher to be ready");
   }
 
   currentSchedule.onComplete.schedule(() {
     _nextEvent = 0;
     _watcher = null;
   }, "reset watcher");
 
   return _watcher;
 }
 
-void expectEvent(ChangeType type, String path) {
-  // Immediately create the future. This ensures we don't register too late and
-  // drop the event before we receive it.
-  var future = _watcher.events.elementAt(_nextEvent++).then((event) {
-    expect(event, new _ChangeMatcher(type, path));
-  });
+/// Expects that the next set of events will all be changes of [type] on
+/// [paths].
+///
+/// Validates that events are delivered for all paths in [paths], but allows
+/// them in any order.
+void expectEvents(ChangeType type, Iterable<String> paths) {
+  var pathSet = paths.map((path) => p.join(_sandboxDir, path)).toSet();
 
-  // Make sure the schedule is watching it in case it fails.
-  currentSchedule.wrapFuture(future);
+  // Create an expectation for as many paths as we have.
+  var futures = [];
+
+  for (var i = 0; i < paths.length; i++) {
+    // Immediately create the futures. This ensures we don't register too
+    // late and drop the event before we receive it.
+    var future = _watcher.events.elementAt(_nextEvent++).then((event) {
+      expect(event.type, equals(type));
+      expect(pathSet, contains(event.path));
+
+      pathSet.remove(event.path);
+    });
+
+    // Make sure the schedule is watching it in case it fails.
+    currentSchedule.wrapFuture(future);
+
+    futures.add(future);
+  }
 
   // Schedule it so that later file modifications don't occur until after this
   // event is received.
-  schedule(() => future, "wait for $type event");
+  schedule(() => Future.wait(futures),
+      "wait for $type events on ${paths.join(', ')}");
 }
 
-void expectAddEvent(String path) {
-  expectEvent(ChangeType.ADD, p.join(_sandboxDir, path));
-}
+void expectAddEvent(String path) => expectEvents(ChangeType.ADD, [path]);
+void expectModifyEvent(String path) => expectEvents(ChangeType.MODIFY, [path]);
+void expectRemoveEvent(String path) => expectEvents(ChangeType.REMOVE, [path]);
 
-void expectModifyEvent(String path) {
-  expectEvent(ChangeType.MODIFY, p.join(_sandboxDir, path));
-}
-
-void expectRemoveEvent(String path) {
-  expectEvent(ChangeType.REMOVE, p.join(_sandboxDir, path));
+void expectRemoveEvents(Iterable<String> paths) {
+  expectEvents(ChangeType.REMOVE, paths);
 }
 
 /// Schedules writing a file in the sandbox at [path] with [contents].
 ///
 /// If [contents] is omitted, creates an empty file. If [updatedModified] is
 /// `false`, the mock file modification time is not changed.
 void writeFile(String path, {String contents, bool updateModified}) {
   if (contents == null) contents = "";
   if (updateModified == null) updateModified = true;
 
@@ skipping 35 matching lines @@
 
     // Make sure we always use the same separator on Windows.
     to = p.normalize(to);
 
     // Manually update the mock modification time for the file.
     var milliseconds = _mockFileModificationTimes.putIfAbsent(to, () => 0);
     _mockFileModificationTimes[to]++;
   }, "rename file $from to $to");
 }
 
+/// Schedules deleting a directory in the sandbox at [path].
+void deleteDir(String path) {
+  schedule(() {
+    new Directory(p.join(_sandboxDir, path)).deleteSync(recursive: true);
+  }, "delete directory $path");
+}
+
 /// A [Matcher] for [WatchEvent]s.
 class _ChangeMatcher extends Matcher {
   /// The expected change.
   final ChangeType type;
 
   /// The expected path.
   final String path;
 
   _ChangeMatcher(this.type, this.path);
 
   Description describe(Description description) {
     description.add("$type $path");
   }
 
   bool matches(item, Map matchState) =>
       item is WatchEvent &&
       item.type == type &&
       p.normalize(item.path) == p.normalize(path);
 }