refactor: update watcher tests to use public interface of fsnotify to prevent race condition in tests

Author: a-h

.version

@@ -1 +1 @@
-0.3.927
+0.3.931

cmd/templ/generatecmd/cmd.go

@@ -306,12 +306,17 @@ func (cmd *Generate) walkAndWatch(ctx context.Context, events chan fsnotify.Even
 		return
 	}
 	cmd.Log.Info("Watching files")
-	rw, err := watcher.Recursive(ctx, cmd.Args.Path, cmd.Args.WatchPattern, events, errs)
+	rw, err := watcher.Recursive(ctx, cmd.Args.WatchPattern, events, errs)
 	if err != nil {
 		cmd.Log.Error("Recursive watcher setup failed, exiting", slog.Any("error", err))
 		errs <- FatalError{Err: fmt.Errorf("failed to setup recursive watcher: %w", err)}
 		return
 	}
+	if err = rw.Add(cmd.Args.Path); err != nil {
+		cmd.Log.Error("Failed to add path to watcher", slog.Any("error", err))
+		errs <- FatalError{Err: fmt.Errorf("failed to add path to watcher: %w", err)}
+		return
+	}
 	defer func() {
 		if err := rw.Close(); err != nil {
 			cmd.Log.Error("Failed to close watcher", slog.Any("error", err))

cmd/templ/generatecmd/watcher/watch.go

@@ -15,7 +15,6 @@ import (
 
 func Recursive(
 	ctx context.Context,
-	path string,
 	watchPattern *regexp.Regexp,
 	out chan fsnotify.Event,
 	errors chan error,
@@ -24,20 +23,21 @@ func Recursive(
 	if err != nil {
 		return nil, err
 	}
-	w = NewRecursiveWatcher(ctx, fsnw, watchPattern, out, errors)
-	go w.loop()
-	return w, w.Add(path)
-}
-
-func NewRecursiveWatcher(ctx context.Context, w *fsnotify.Watcher, watchPattern *regexp.Regexp, events chan fsnotify.Event, errors chan error) *RecursiveWatcher {
-	return &RecursiveWatcher{
+	w = &RecursiveWatcher{
 		ctx:          ctx,
-		w:            w,
+		w:            fsnw,
 		WatchPattern: watchPattern,
-		Events:       events,
+		Events:       out,
 		Errors:       errors,
 		timers:       make(map[timerKey]*time.Timer),
+		loopComplete: sync.WaitGroup{},
 	}
+	w.loopComplete.Add(1)
+	go func() {
+		defer w.loopComplete.Done()
+		w.loop()
+	}()
+	return w, nil
 }
 
 // WalkFiles walks the file tree rooted at path, sending a Create event for each
@@ -73,6 +73,7 @@ type RecursiveWatcher struct {
 	Errors       chan error
 	timerMu      sync.Mutex
 	timers       map[timerKey]*time.Timer
+	loopComplete sync.WaitGroup
 }
 
 type timerKey struct {
@@ -88,6 +89,10 @@ func timerKeyFromEvent(event fsnotify.Event) timerKey {
 }
 
 func (w *RecursiveWatcher) Close() error {
+	w.loopComplete.Wait()
+	for _, timer := range w.timers {
+		timer.Stop()
+	}
 	return w.w.Close()
 }
 
@@ -115,6 +120,9 @@ func (w *RecursiveWatcher) loop() {
 			w.timerMu.Unlock()
 			if !ok {
 				t = time.AfterFunc(100*time.Millisecond, func() {
+					if w.ctx.Err() != nil {
+						return
+					}
 					w.Events <- event
 				})
 				w.timerMu.Lock()

cmd/templ/generatecmd/watcher/watch_test.go

@@ -12,23 +12,20 @@ import (
 
 func TestWatchDebouncesDuplicates(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	w := &fsnotify.Watcher{
-		Events: make(chan fsnotify.Event),
-	}
 	events := make(chan fsnotify.Event, 2)
 	errors := make(chan error)
 	watchPattern, err := regexp.Compile(".*")
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 	}
-	rw := NewRecursiveWatcher(ctx, w, watchPattern, events, errors)
+	rw, err := Recursive(ctx, watchPattern, events, errors)
+	if err != nil {
+		t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
+	}
 	go func() {
 		rw.w.Events <- fsnotify.Event{Name: "test.templ"}
 		rw.w.Events <- fsnotify.Event{Name: "test.templ"}
-		cancel()
-		close(rw.w.Events)
 	}()
-	rw.loop()
 	count := 0
 	exp := time.After(300 * time.Millisecond)
 	for {
@@ -39,6 +36,8 @@ func TestWatchDebouncesDuplicates(t *testing.T) {
 			if count != 1 {
 				t.Errorf("expected 1 event, got %d", count)
 			}
+			cancel()
+			rw.Close()
 			return
 		}
 	}
@@ -64,23 +63,20 @@ func TestWatchDoesNotDebounceDifferentEvents(t *testing.T) {
 	}
 	for _, test := range tests {
 		ctx, cancel := context.WithCancel(context.Background())
-		w := &fsnotify.Watcher{
-			Events: make(chan fsnotify.Event),
-		}
 		events := make(chan fsnotify.Event, 2)
 		errors := make(chan error)
 		watchPattern, err := regexp.Compile(".*")
 		if err != nil {
 			t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 		}
-		rw := NewRecursiveWatcher(ctx, w, watchPattern, events, errors)
+		rw, err := Recursive(ctx, watchPattern, events, errors)
+		if err != nil {
+			t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
+		}
 		go func() {
 			rw.w.Events <- test.event1
 			rw.w.Events <- test.event2
-			cancel()
-			close(rw.w.Events)
 		}()
-		rw.loop()
 		count := 0
 		exp := time.After(300 * time.Millisecond)
 		for {
@@ -91,6 +87,8 @@ func TestWatchDoesNotDebounceDifferentEvents(t *testing.T) {
 				if count != 2 {
 					t.Errorf("expected 2 event, got %d", count)
 				}
+				cancel()
+				rw.Close()
 				return
 			}
 		}
@@ -99,24 +97,21 @@ func TestWatchDoesNotDebounceDifferentEvents(t *testing.T) {
 
 func TestWatchDoesNotDebounceSeparateEvents(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	w := &fsnotify.Watcher{
-		Events: make(chan fsnotify.Event),
-	}
 	events := make(chan fsnotify.Event, 2)
 	errors := make(chan error)
 	watchPattern, err := regexp.Compile(".*")
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 	}
-	rw := NewRecursiveWatcher(ctx, w, watchPattern, events, errors)
+	rw, err := Recursive(ctx, watchPattern, events, errors)
+	if err != nil {
+		t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
+	}
 	go func() {
 		rw.w.Events <- fsnotify.Event{Name: "test.templ"}
 		<-time.After(200 * time.Millisecond)
 		rw.w.Events <- fsnotify.Event{Name: "test.templ"}
-		cancel()
-		close(rw.w.Events)
 	}()
-	rw.loop()
 	count := 0
 	exp := time.After(500 * time.Millisecond)
 	for {
@@ -127,6 +122,8 @@ func TestWatchDoesNotDebounceSeparateEvents(t *testing.T) {
 			if count != 2 {
 				t.Errorf("expected 2 event, got %d", count)
 			}
+			cancel()
+			rw.Close()
 			return
 		}
 	}