Adjust tests to show link creation races on windows, fix watcher.

Author: davidmorgan

pkgs/watcher/lib/src/directory_watcher/windows.dart

@@ -261,6 +261,27 @@ class _WindowsDirectoryWatcher
   Map<String, Set<Event>> _sortEvents(List<Event> batch) {
     var eventsForPaths = <String, Set<Event>>{};
 
+    // On Windows new links to directories are sometimes reported by
+    // Directory.watch as directories. On all other platforms it reports them
+    // consistently as files. See https://github.com/dart-lang/sdk/issues/61797.
+    //
+    // The wrong type is because Windows creates links to directories as actual
+    // directories, then converts them to links. Directory.watch sometimes
+    // checks the type too early and gets the wrong result.
+    //
+    // The batch delay is plenty for the link to be fully created, so verify the
+    // file system entity type for all createDirectory` events, converting to
+    // `createFile` when needed.
+    for (var i = 0; i != batch.length; ++i) {
+      final event = batch[i];
+      if (event.type == EventType.createDirectory) {
+        if (FileSystemEntity.typeSync(event.path, followLinks: false) ==
+            FileSystemEntityType.link) {
+          batch[i] = Event.createFile(event.path);
+        }
+      }
+    }
+
     // Events within directories that already have create events are not needed
     // as the directory's full content will be listed.
     var createdDirectories = unionAll(batch.map((event) {

pkgs/watcher/test/directory_watcher/link_tests.dart

@@ -21,7 +21,8 @@ void _linkTests({required bool isNative}) {
     writeFile('targets/a.target');
     await startWatcher(path: 'links');
 
-    writeLink(link: 'links/a.link', target: 'targets/a.target');
+    writeLink(
+        link: 'links/a.link', target: 'targets/a.target', unawaitedAsync: true);
 
     await expectAddEvent('links/a.link');
   });
@@ -109,7 +110,10 @@ void _linkTests({required bool isNative}) {
     createDir('targets/a.targetdir');
     await startWatcher(path: 'links');
 
-    writeLink(link: 'links/a.link', target: 'targets/a.targetdir');
+    writeLink(
+        link: 'links/a.link',
+        target: 'targets/a.targetdir',
+        unawaitedAsync: true);
 
     // TODO(davidmorgan): reconcile differences.
     if (isNative) {
@@ -128,7 +132,10 @@ void _linkTests({required bool isNative}) {
     writeFile('targets/a.targetdir/a.target');
     await startWatcher(path: 'links');
 
-    writeLink(link: 'links/a.link', target: 'targets/a.targetdir');
+    writeLink(
+        link: 'links/a.link',
+        target: 'targets/a.targetdir',
+        unawaitedAsync: true);
 
     // TODO(davidmorgan): reconcile differences.
     if (isNative) {

pkgs/watcher/test/utils.dart

@@ -12,7 +12,8 @@ import 'package:test_descriptor/test_descriptor.dart' as d;
 import 'package:watcher/watcher.dart';
 
 /// Edit this to run fast-running tests many times.
-int runsPerTest = 1;
+/// DO NOT SUBMIT
+int runsPerTest = 5;
 
 typedef WatcherFactory = Watcher Function(String directory);
 
@@ -239,9 +240,21 @@ void writeFile(String path, {String? contents}) {
 /// Writes a file in the sandbox at [link] pointing to [target].
 ///
 /// [target] is relative to the sandbox, not to [link].
+///
+/// If [unawaitedAsync], the link is written asynchronously and not awaited.
+/// Otherwise, it's synchronous.
+///
+/// Async creation of links Is needed to fully test links on Windows because
+/// creation of links to directories on Windows is not atomic. First a directory
+/// is created, then it is converted into a link. Directory.watch checks the
+/// filesystem entity type to decide what to report, and this races with the
+/// second step. As a result it sometimes reports a directory creation and
+/// sometimes reports a file creation. See
+/// https://github.com/dart-lang/sdk/issues/61797.
 void writeLink({
   required String link,
   required String target,
+  bool unawaitedAsync = false,
 }) {
   var fullPath = p.join(d.sandbox, link);
 
@@ -251,7 +264,11 @@ void writeLink({
     dir.createSync(recursive: true);
   }
 
-  Link(fullPath).createSync(p.join(d.sandbox, target));
+  if (unawaitedAsync) {
+    unawaited(Link(fullPath).create(p.join(d.sandbox, target)));
+  } else {
+    Link(fullPath).createSync(p.join(d.sandbox, target));
+  }
 }
 
 /// Deletes a file in the sandbox at [path].