fix: Resolve race condition in file provider and TestUnwatchFile

Fixes race conditions detected when running tests with -race flag.

## Root Cause
The file provider had a race condition where:
1. Watch() assigns to f.w (fsnotify.Watcher field)
2. Previous watcher's cleanup goroutine calls f.w.Close()
3. These operations could happen concurrently when re-watching after unwatch

Additionally, TestUnwatchFile had a race between:
- Main test goroutine reading/writing `reloaded` boolean variable
- Watch callback goroutine writing to `reloaded` variable

## Solution
1. **File Provider**: Add mutex protection around watcher state changes
   - Added `mu sync.Mutex` to File struct
   - Protected Watch() and Unwatch() methods with mutex
   - Protected cleanup code in watch goroutine with mutex
   - Added nil checks for defensive programming

2. **TestUnwatchFile**: Use atomic operations instead of plain boolean
   - Changed `reloaded bool` to `reloaded int32`
   - Use atomic.StoreInt32/LoadInt32 for thread-safe access
   - Test now properly verifies re-watching capability after unwatch

## Testing
- All watch-related tests pass with race detector: TestWatchFile, TestWatchFileSymlink, TestWatchFileDirectorySymlink, TestUnwatchFile
- All submodule tests continue to pass with race detection
- CI pattern `github.com/knadh/koanf...` properly tests all submodules

Created using prompt: "alright, lets then do a separate commit now to fix the test unwatch file race" and "maybe a better approach will be to add a mutex for file watcher instad?"

Author: rhnvrm

providers/file/file.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -19,6 +20,9 @@ type File struct {
 	path string
 	w    *fsnotify.Watcher
 
+	// Mutex to protect concurrent access to watcher state
+	mu sync.Mutex
+
 	// Using Go 1.18 atomic functions for backwards compatibility.
 	isWatching  uint32
 	isUnwatched uint32
@@ -42,6 +46,9 @@ func (f *File) Read() (map[string]interface{}, error) {
 // Watch watches the file and triggers a callback when it changes. It is a
 // blocking function that internally spawns a goroutine to watch for changes.
 func (f *File) Watch(cb func(event interface{}, err error)) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
 	// If a watcher already exists, return an error.
 	if atomic.LoadUint32(&f.isWatching) == 1 {
 		return errors.New("file is already being watched")
@@ -140,9 +147,14 @@ func (f *File) Watch(cb func(event interface{}, err error)) error {
 			}
 		}
 
+		f.mu.Lock()
 		atomic.StoreUint32(&f.isWatching, 0)
 		atomic.StoreUint32(&f.isUnwatched, 0)
-		f.w.Close()
+		if f.w != nil {
+			f.w.Close()
+			f.w = nil
+		}
+		f.mu.Unlock()
 	}()
 
 	// Watch the directory for changes.
@@ -151,6 +163,12 @@ func (f *File) Watch(cb func(event interface{}, err error)) error {
 
 // Unwatch stops watching the files and closes fsnotify watcher.
 func (f *File) Unwatch() error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
 	atomic.StoreUint32(&f.isUnwatched, 1)
-	return f.w.Close()
+	if f.w != nil {
+		return f.w.Close()
+	}
+	return nil
 }

tests/koanf_test.go

@@ -637,35 +637,35 @@ func TestUnwatchFile(t *testing.T) {
 	k.Load(f, json.Parser())
 
 	// Watch.
-	reloaded := false
+	var reloaded int32
 	f.Watch(func(event interface{}, err error) {
-		reloaded = true
+		atomic.StoreInt32(&reloaded, 1)
 		assert.NoError(err)
 	})
 
 	// Change the file and check whether the watch triggered.
 	time.Sleep(100 * time.Millisecond)
 	os.WriteFile(tmpFile, []byte(`{"parent": {"name": "name2"}}`), 0600)
 	time.Sleep(100 * time.Millisecond)
-	assert.True(reloaded, "watched file didn't reload")
+	assert.True(atomic.LoadInt32(&reloaded) == 1, "watched file didn't reload")
 
 	// Unwatch the file and verify that the watch didn't trigger.
 	assert.NoError(f.Unwatch())
-	reloaded = false
+	atomic.StoreInt32(&reloaded, 0)
 	time.Sleep(100 * time.Millisecond)
 	os.WriteFile(tmpFile, []byte(`{"parent": {"name": "name3"}}`), 0600)
 	time.Sleep(100 * time.Millisecond)
-	assert.False(reloaded, "unwatched file reloaded")
+	assert.False(atomic.LoadInt32(&reloaded) == 1, "unwatched file reloaded")
 
 	// Re-watch and check again.
-	reloaded = false
+	atomic.StoreInt32(&reloaded, 0)
 	f.Watch(func(event interface{}, err error) {
-		reloaded = true
+		atomic.StoreInt32(&reloaded, 1)
 		assert.NoError(err)
 	})
 	os.WriteFile(tmpFile, []byte(`{"parent": {"name": "name4"}}`), 0600)
 	time.Sleep(100 * time.Millisecond)
-	assert.True(reloaded, "watched file didn't reload")
+	assert.True(atomic.LoadInt32(&reloaded) == 1, "watched file didn't reload")
 
 	f.Unwatch()
 }