👔 up: handler - update some handler and add more test cases

handler/config_test.go

@@ -22,6 +22,9 @@ func TestNewConfig(t *testing.T) {
 		handler.WithRotateMode(rotatefile.ModeCreate),
 		func(c *handler.Config) {
 			c.BackupTime = 23
+			c.RenameFunc = func(fpath string, num uint) string {
+				return fpath + ".bak"
+			}
 		},
 	).
 		With(handler.WithBuffSize(129)).
@@ -120,12 +123,30 @@ func (w *flushCloseWriter) Flush() error {
 	return nil
 }
 
+type syncCloseWriter struct {
+	closeWriter
+	errOnSync bool
+}
+
+// Sync implement stdio.Syncer
+func (w *syncCloseWriter) Sync() error {
+	if w.errOnSync {
+		return errorx.Raw("sync error")
+	}
+	return nil
+}
+
 func TestNewBuilder_buildFromWriter(t *testing.T) {
 	t.Run("FlushCloseWriter", func(t *testing.T) {
 		out := &flushCloseWriter{}
 		out.errOnFlush = true
 		h := handler.NewBuilder().
 			WithOutput(out).
+			WithConfigFn(func(c *handler.Config) {
+				c.RenameFunc = func(fpath string, num uint) string {
+					return fpath + ".bak"
+				}
+			}).
 			Build()
 		assert.Err(t, h.Flush())
 

handler/handler_test.go

@@ -1,14 +1,14 @@
 package handler_test
 
 import (
-	"fmt"
+	"log/syslog"
 	"testing"
 
 	"github.com/gookit/goutil"
 	"github.com/gookit/goutil/errorx"
 	"github.com/gookit/goutil/fsutil"
+	"github.com/gookit/goutil/sysutil"
 	"github.com/gookit/goutil/testutil/assert"
-	"github.com/gookit/goutil/testutil/fakeobj"
 	"github.com/gookit/slog"
 	"github.com/gookit/slog/handler"
 )
@@ -125,33 +125,6 @@ func TestLevelsWithFormatter(t *testing.T) {
 	assert.True(t, lsf.IsHandling(slog.DebugLevel))
 }
 
-func TestNewSimpleHandler(t *testing.T) {
-	buf := fakeobj.NewWriter()
-
-	h := handler.NewSimple(buf, slog.InfoLevel)
-	r := newLogRecord("test simple handler")
-	assert.NoErr(t, h.Handle(r))
-
-	s := buf.String()
-	buf.Reset()
-	fmt.Print(s)
-	assert.Contains(t, s, "test simple handler")
-
-	assert.NoErr(t, h.Flush())
-	assert.NoErr(t, h.Close())
-
-	h = handler.NewHandler(buf, slog.InfoLevel)
-	r = newLogRecord("test simple handler2")
-	assert.NoErr(t, h.Handle(r))
-
-	s = buf.ResetGet()
-	fmt.Print(s)
-	assert.Contains(t, s, "test simple handler2")
-
-	assert.NoErr(t, h.Flush())
-	assert.NoErr(t, h.Close())
-}
-
 func TestNopFlushClose_Flush(t *testing.T) {
 	nfc := handler.NopFlushClose{}
 
@@ -173,6 +146,21 @@ func TestLockWrapper_Lock(t *testing.T) {
 	assert.Eq(t, 2, a)
 }
 
+func TestNewSysLogHandler(t *testing.T) {
+	if sysutil.IsWin() {
+		t.Skip("skip test on windows")
+	}
+
+	h, err := handler.NewSysLogHandler(syslog.LOG_INFO, "slog")
+	assert.NoErr(t, err)
+
+	err = h.Handle(newLogRecord("test syslog handler"))
+	assert.NoErr(t, err)
+
+	assert.NoErr(t, h.Flush())
+	assert.NoErr(t, h.Close())
+}
+
 func logAllLevel(log slog.SLogger, msg string) {
 	for _, level := range slog.AllLevels {
 		log.Log(level, msg)

handler/rotatefile.go

@@ -35,8 +35,8 @@ func NewRotateFile(logfile string, rt rotatefile.RotateTime, fns ...ConfigFn) (*
 //
 
 // MustSizeRotateFile instance
-func MustSizeRotateFile(logfile string, size int, fns ...ConfigFn) *SyncCloseHandler {
-	return basefn.Must(NewSizeRotateFileHandler(logfile, size, fns...))
+func MustSizeRotateFile(logfile string, maxSize int, fns ...ConfigFn) *SyncCloseHandler {
+	return basefn.Must(NewSizeRotateFileHandler(logfile, maxSize, fns...))
 }
 
 // NewSizeRotateFile instance

handler/rotatefile_test.go

@@ -2,7 +2,7 @@ package handler_test
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"testing"
 	"time"
 
@@ -36,8 +36,7 @@ func TestNewRotateFileHandler(t *testing.T) {
 	logfile = "./testdata/both-rotate-bytime.log"
 	assert.NoErr(t, fsutil.DeleteIfFileExist(logfile))
 
-	h, err = handler.NewRotateFileHandler(logfile, handler.EverySecond)
-	assert.NoErr(t, err)
+	h = handler.MustRotateFile(logfile, handler.EverySecond)
 	assert.True(t, fsutil.IsFile(logfile))
 
 	l = slog.NewWithHandlers(h)
@@ -54,24 +53,37 @@ func TestNewRotateFileHandler(t *testing.T) {
 }
 
 func TestNewSizeRotateFileHandler(t *testing.T) {
-	logfile := "./testdata/size-rotate-file.log"
-	assert.NoErr(t, fsutil.DeleteIfFileExist(logfile))
-
-	h, err := handler.NewSizeRotateFileHandler(logfile, 468, handler.WithBuffSize(256))
-	assert.NoErr(t, err)
-	assert.True(t, fsutil.IsFile(logfile))
-
-	l := slog.NewWithHandlers(h)
-	l.ReportCaller = true
-	l.CallerFlag = slog.CallerFlagFull
-
-	for i := 0; i < 4; i++ {
-		l.Info("this is a info", "message, index=", i)
-		l.Warn("this is a warn message, index=", i)
-	}
-
-	assert.NoErr(t, l.Close())
-	checkLogFileContents(t, logfile)
+	t.Run("NewSizeRotateFile", func(t *testing.T) {
+		logfile := "./testdata/size-rotate-file.log"
+		assert.NoErr(t, fsutil.DeleteIfFileExist(logfile))
+
+		h, err := handler.NewSizeRotateFile(logfile, 468, handler.WithBuffSize(256))
+		assert.NoErr(t, err)
+		assert.True(t, fsutil.IsFile(logfile))
+
+		l := slog.NewWithHandlers(h)
+		l.ReportCaller = true
+		l.CallerFlag = slog.CallerFlagFull
+
+		for i := 0; i < 4; i++ {
+			l.Info("this is a info", "message, index=", i)
+			l.Warn("this is a warn message, index=", i)
+		}
+
+		assert.NoErr(t, l.Close())
+		checkLogFileContents(t, logfile)
+	})
+
+	t.Run("MustSizeRotateFile", func(t *testing.T) {
+		logfile := "./testdata/must-size-rotate-file.log"
+		h := handler.MustSizeRotateFile(logfile, 128, handler.WithBuffSize(128))
+		h.SetFormatter(slog.NewJSONFormatter())
+		err := h.Handle(newLogRecord("this is a info message"))
+		assert.NoErr(t, err)
+
+		files := fsutil.Glob(logfile + "*")
+		assert.Len(t, files, 2)
+	})
 }
 
 func TestNewTimeRotateFileHandler_EveryDay(t *testing.T) {
@@ -188,7 +200,7 @@ func TestNewTimeRotateFileHandler_someSeconds(t *testing.T) {
 func checkLogFileContents(t *testing.T, logfile string) {
 	assert.True(t, fsutil.IsFile(logfile))
 
-	bts, err := ioutil.ReadFile(logfile)
+	bts, err := os.ReadFile(logfile)
 	assert.NoErr(t, err)
 
 	str := string(bts)

handler/syslog.go

@@ -1,5 +1,4 @@
 //go:build !windows && !nacl && !plan9
-// +build !windows,!nacl,!plan9
 
 package handler
 

handler/write_closer.go

@@ -26,6 +26,10 @@ func WriteCloserWithMaxLevel(out io.WriteCloser, maxLevel slog.Level) *WriteClos
 	return NewWriteCloserWithLF(out, slog.NewLvFormatter(maxLevel))
 }
 
+//
+// ------------- Use multi log levels -------------
+//
+
 // WriteCloserWithLevels create a new instance and with limited log levels
 func WriteCloserWithLevels(out io.WriteCloser, levels []slog.Level) *WriteCloserHandler {
 	// h := &WriteCloserHandler{Output: out}

handler/writer_test.go

@@ -2,6 +2,7 @@ package handler_test
 
 import (
 	"bytes"
+	"fmt"
 	"testing"
 
 	"github.com/gookit/goutil/fsutil"
@@ -45,13 +46,22 @@ func TestNewSyncCloser(t *testing.T) {
 	assert.NoErr(t, err)
 	assert.NoErr(t, h.Flush())
 
-	bts := fsutil.MustReadFile(logfile)
-	str := string(bts)
-
+	str := fsutil.ReadString(logfile)
 	assert.Contains(t, str, "test sync closer handler")
+	assert.NoErr(t, h.Close())
 
-	err = h.Close()
-	assert.NoErr(t, err)
+	t.Run("err on sync", func(t *testing.T) {
+		w := &syncCloseWriter{}
+		w.errOnSync = true
+		h = handler.SyncCloserWithLevels(w, slog.NormalLevels)
+
+		assert.Err(t, h.Flush())
+		assert.Err(t, h.Close())
+	})
+
+	// test handle error
+	h.SetFormatter(newTestFormatter(true))
+	assert.Err(t, h.Handle(r))
 }
 
 func TestNewWriteCloser(t *testing.T) {
@@ -66,8 +76,23 @@ func TestNewWriteCloser(t *testing.T) {
 
 	str := w.String()
 	assert.Contains(t, str, "test writeCloser handler")
-
 	assert.NoErr(t, h.Close())
+
+	t.Run("use max level", func(t *testing.T) {
+		h = handler.WriteCloserWithMaxLevel(w, slog.WarnLevel)
+		r = newLogRecord("test max level")
+		assert.False(t, h.IsHandling(r.Level))
+
+		r.Level = slog.ErrorLevel
+		assert.True(t, h.IsHandling(r.Level))
+	})
+
+	// test handle error
+	t.Run("handle error", func(t *testing.T) {
+		h = handler.WriteCloserWithLevels(w, slog.NormalLevels)
+		h.SetFormatter(newTestFormatter(true))
+		assert.Err(t, h.Handle(r))
+	})
 }
 
 func TestNewFlushCloser(t *testing.T) {
@@ -84,17 +109,65 @@ func TestNewFlushCloser(t *testing.T) {
 	assert.NoErr(t, h.Flush())
 	assert.NoErr(t, h.Close())
 
+	t.Run("ErrOnFlush", func(t *testing.T) {
+		w.ErrOnFlush = true
+		assert.Err(t, h.Flush())
+		assert.Err(t, h.Close())
+	})
+
+	t.Run("With max level", func(t *testing.T) {
+		h = handler.FlushCloserWithMaxLevel(w, slog.WarnLevel)
+		r = newLogRecord("test max level")
+		assert.False(t, h.IsHandling(r.Level))
+		assert.Empty(t, w.String())
+
+		r.Level = slog.ErrorLevel
+		assert.True(t, h.IsHandling(r.Level))
+		assert.NoErr(t, h.Handle(r))
+		assert.NotEmpty(t, w.String())
+	})
+
+	// test handle error
 	h = handler.FlushCloserWithMaxLevel(w, slog.WarnLevel)
-	r = newLogRecord("test max level")
-	assert.False(t, h.IsHandling(r.Level))
-	assert.Empty(t, w.String())
+	h.SetFormatter(newTestFormatter(true))
+	assert.Err(t, h.Handle(r))
+}
 
-	r.Level = slog.ErrorLevel
-	assert.True(t, h.IsHandling(r.Level))
+func TestNewSimpleHandler(t *testing.T) {
+	buf := fakeobj.NewWriter()
+
+	h := handler.NewSimple(buf, slog.InfoLevel)
+	r := newLogRecord("test simple handler")
 	assert.NoErr(t, h.Handle(r))
-	assert.NotEmpty(t, w.String())
 
-	// test handle error
+	s := buf.String()
+	buf.Reset()
+	fmt.Print(s)
+	assert.Contains(t, s, "test simple handler")
+
+	assert.NoErr(t, h.Flush())
+	assert.NoErr(t, h.Close())
+
+	h = handler.NewHandler(buf, slog.InfoLevel)
+	r = newLogRecord("test simple handler2")
+	assert.NoErr(t, h.Handle(r))
+
+	s = buf.ResetGet()
+	fmt.Print(s)
+	assert.Contains(t, s, "test simple handler2")
+
+	assert.NoErr(t, h.Flush())
+	assert.NoErr(t, h.Close())
+
+	h = handler.SimpleWithLevels(buf, slog.NormalLevels)
+	r = newLogRecord("test simple handler with levels")
+	assert.NoErr(t, h.Handle(r))
+
+	s = buf.ResetGet()
+	fmt.Print(s)
+	assert.Contains(t, s, "test simple handler with levels")
+
+	// handle error
 	h.SetFormatter(newTestFormatter(true))
 	assert.Err(t, h.Handle(r))
 }