git-webhook-ci/internal/watcher/watcher_test.go

163 lines
3.0 KiB
Go

package watcher
import (
"context"
"errors"
"testing"
"time"
"gitea.urkob.com/urko/git-webhook-ci/cfg"
pkgwatcher "gitea.urkob.com/urko/git-webhook-ci/pkg/watcher"
"github.com/fsnotify/fsnotify"
"github.com/stretchr/testify/require"
)
type testErrorNotifier struct {
*fsnotify.Watcher
}
func (n *testErrorNotifier) NewWatcher() (*fsnotify.Watcher, error) {
return nil, errIntentional
}
var (
errNotifier = &testErrorNotifier{}
okNotifier = &notifier{}
)
var (
mockDeploy pkgwatcher.DeployFunc
mockErrorDeploy pkgwatcher.DeployFunc
errIntentional = errors.New("intentional error")
binaryPath = ""
scriptPath = ""
executionMaxTimeout = time.Second * 2
config *cfg.Config
events = []fsnotify.Event{
{
Name: "test event",
Op: fsnotify.Create,
},
{
Name: "Write",
Op: fsnotify.Write,
},
}
)
func init() {
mockDeploy = func(binaryPath, scriptPath string) error {
return nil
}
mockErrorDeploy = func(binaryPath, scriptPath string) error {
return errIntentional
}
config = cfg.NewConfig(false)
}
func sendTestEvents(w *watcher) {
for _, event := range events {
w.fswatcher.Events <- event
}
}
func newWatcher() *watcher {
return NewWatcher(okNotifier, mockDeploy)
}
func newWatcherWithDeployError() *watcher {
return NewWatcher(okNotifier, mockErrorDeploy)
}
func newWatcherWithCtorError() *watcher {
return NewWatcher(errNotifier, mockDeploy)
}
func Test_NewNotifier(t *testing.T) {
require.NotNil(t, NewNotifier())
}
func Test_NewWatcher(t *testing.T) {
w := newWatcher()
require.NotNil(t, w)
}
func Test_ErrorNewWatcher(t *testing.T) {
w := newWatcherWithCtorError()
require.Nil(t, w)
}
func Test_Close(t *testing.T) {
w := newWatcher()
err := w.Close()
require.NoError(t, err)
}
func Test_Monitor(t *testing.T) {
w := newWatcher()
err := w.Monitor(config.TestFileToWatchPath)
require.NoError(t, err)
}
func Test_ListenSuccess(t *testing.T) {
w := newWatcher()
ctx, errors := listenWithSendEvents(w)
for {
select {
case <-ctx.Done():
return
case err := <-errors:
require.NoError(t, err)
return
}
}
}
func Test_ListenError(t *testing.T) {
w := newWatcherWithDeployError()
ctx, errors := listenWithSendEvents(w)
for {
select {
case <-ctx.Done():
return
case err := <-errors:
require.Error(t, err)
require.EqualError(t, err, errIntentional.Error())
return
}
}
}
func Test_ListenErrorChanClose(t *testing.T) {
w := newWatcher()
ctx, errors := listenWithSendEvents(w)
close(w.fswatcher.Events)
for {
select {
case <-ctx.Done():
return
case err := <-errors:
require.Error(t, err)
require.EqualError(t, err, errEventsClosedChan.Error())
return
}
}
}
func listenWithSendEvents(w *watcher) (context.Context, chan error) {
ctx, cancel := context.WithTimeout(context.Background(), executionMaxTimeout)
errors := make(chan error)
w.Listen(binaryPath, scriptPath, errors)
go func(cancel context.CancelFunc) {
time.Sleep(executionMaxTimeout)
cancel()
}(cancel)
sendTestEvents(w)
return ctx, errors
}