Refactor filesystem package

filesystem/handler.go

@@ -0,0 +1,60 @@
+package filesystem
+
+import (
+	"github.com/fsnotify/fsnotify"
+	"path/filepath"
+)
+
+type FileHandler struct {
+	watcher *fsnotify.Watcher
+	file    string
+	eventCh chan<- string
+	errCh   chan<- error
+}
+
+func NewFileHandler(eventCh chan<- string, errCh chan<- error) (*FileHandler, error) {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	fh := FileHandler{
+		watcher: watcher,
+		eventCh: eventCh,
+		errCh:   errCh,
+	}
+	return &fh, nil
+}
+
+func (f *FileHandler) Add(fileName string) error {
+	if err := f.watcher.Add(fileName); err != nil {
+		return err
+	}
+
+	f.file = fileName
+	return nil
+}
+
+func (f *FileHandler) Run() {
+	go func() {
+		for {
+			select {
+			case event := <-f.watcher.Events:
+				if f.writeOrCreate(event) && f.isWatched(event.Name) {
+					f.eventCh <- event.Name
+				}
+			case err := <-f.watcher.Errors:
+				f.errCh <- err
+			}
+		}
+	}()
+}
+
+func (f *FileHandler) writeOrCreate(event fsnotify.Event) bool {
+	return (event.Op&fsnotify.Write == fsnotify.Write) || (event.Op&fsnotify.Create == fsnotify.Create)
+}
+
+func (f *FileHandler) isWatched(filePath string) bool {
+	_, file := filepath.Split(filePath)
+	return file == f.file
+}

filesystem/watcher_test.go → filesystem/handler_test.go

@@ -8,28 +8,48 @@ import (
 	"testing"
 )
 
-func TestFsnotifyWatcher_Run(t *testing.T) {
-	watchedFile := "watchthis.txt"
-	_, err := os.Create(watchedFile)
+const watchedFile = "watchthis.txt"
+
+func TestMain(m *testing.M) {
+	os.Create(watchedFile)
+
+	testResult := m.Run()
+
+	os.Remove(watchedFile)
+	os.Exit(testResult)
+}
+
+func TestFileHandler_Add(t *testing.T) {
+	eventChan := make(chan string)
+	errorChan := make(chan error)
+
+	fileHandler, err := NewFileHandler(eventChan, errorChan)
+	assert.NoError(t, err)
+
+	err = fileHandler.Add(watchedFile)
 	assert.NoError(t, err)
 
+	assert.Equal(t, watchedFile, fileHandler.file)
+}
+
+func TestFileHandler_Run(t *testing.T) {
 	eventChan := make(chan string)
 	errorChan := make(chan error)
 
-	watcher, err := NewWatcher(eventChan, errorChan)
+	fileHandler, err := NewFileHandler(eventChan, errorChan)
 	assert.NoError(t, err)
 
-	err = watcher.Add(watchedFile)
+	err = fileHandler.Add(watchedFile)
 	assert.NoError(t, err)
 
-	watcher.Run()
+	fileHandler.Run()
 
 	t.Run("sends event on WRITE", func(t *testing.T) {
 		event := fsnotify.Event{
 			Name: watchedFile,
 			Op:   fsnotify.Write,
 		}
-		watcher.(*fsnotifyWatcher).watcher.Events <- event
+		fileHandler.watcher.Events <- event
 
 		receivedFile := <-eventChan
 		assert.Equal(t, watchedFile, receivedFile)
@@ -40,19 +60,16 @@ func TestFsnotifyWatcher_Run(t *testing.T) {
 			Name: watchedFile,
 			Op:   fsnotify.Create,
 		}
-		watcher.(*fsnotifyWatcher).watcher.Events <- event
+		fileHandler.watcher.Events <- event
 
 		receivedFile := <-eventChan
 		assert.Equal(t, watchedFile, receivedFile)
 	})
 
 	t.Run("sends error", func(t *testing.T) {
-		watcher.(*fsnotifyWatcher).watcher.Errors <- errors.New("something happened")
+		fileHandler.watcher.Errors <- errors.New("something happened")
 
 		receivedError := <-errorChan
 		assert.Error(t, receivedError, "something happened")
 	})
-
-	err = os.Remove(watchedFile)
-	assert.NoError(t, err)
 }