pkg.re/essentialkaos/ek.10@v12.41.0+incompatible/log/log_test.go (about)

     1  package log
     2  
     3  // ////////////////////////////////////////////////////////////////////////////////// //
     4  //                                                                                    //
     5  //                         Copyright (c) 2022 ESSENTIAL KAOS                          //
     6  //      Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0>     //
     7  //                                                                                    //
     8  // ////////////////////////////////////////////////////////////////////////////////// //
     9  
    10  import (
    11  	"io/ioutil"
    12  	"os"
    13  	"strings"
    14  	"sync"
    15  	"testing"
    16  	"time"
    17  
    18  	. "pkg.re/essentialkaos/check.v1"
    19  
    20  	"pkg.re/essentialkaos/ek.v12/fsutil"
    21  )
    22  
    23  // ////////////////////////////////////////////////////////////////////////////////// //
    24  
    25  type LogSuite struct {
    26  	TempDir string
    27  }
    28  
    29  // ////////////////////////////////////////////////////////////////////////////////// //
    30  
    31  func Test(t *testing.T) { TestingT(t) }
    32  
    33  // ////////////////////////////////////////////////////////////////////////////////// //
    34  
    35  var _ = Suite(&LogSuite{})
    36  
    37  // ////////////////////////////////////////////////////////////////////////////////// //
    38  
    39  func (ls *LogSuite) SetUpSuite(c *C) {
    40  	ls.TempDir = c.MkDir()
    41  }
    42  
    43  func (ls *LogSuite) SetUpTest(c *C) {
    44  	Global = &Logger{
    45  		PrefixWarn:  true,
    46  		PrefixError: true,
    47  		PrefixCrit:  true,
    48  
    49  		minLevel: INFO,
    50  		mu:       &sync.Mutex{},
    51  	}
    52  }
    53  
    54  // ////////////////////////////////////////////////////////////////////////////////// //
    55  
    56  func (ls *LogSuite) TestErrors(c *C) {
    57  	var l *Logger
    58  
    59  	l.MinLevel(DEBUG)
    60  
    61  	err := l.Flush()
    62  
    63  	c.Assert(err, NotNil)
    64  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    65  
    66  	err = l.Reopen()
    67  
    68  	c.Assert(err, NotNil)
    69  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    70  
    71  	err = l.Print(DEBUG, "test")
    72  
    73  	c.Assert(err, NotNil)
    74  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    75  
    76  	err = l.Debug("test")
    77  
    78  	c.Assert(err, NotNil)
    79  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    80  
    81  	err = l.Info("test")
    82  
    83  	c.Assert(err, NotNil)
    84  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    85  
    86  	err = l.Warn("test")
    87  
    88  	c.Assert(err, NotNil)
    89  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    90  
    91  	err = l.Error("test")
    92  
    93  	c.Assert(err, NotNil)
    94  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
    95  
    96  	err = l.Crit("test")
    97  
    98  	c.Assert(err, NotNil)
    99  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
   100  
   101  	err = l.Aux("test")
   102  
   103  	c.Assert(err, NotNil)
   104  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
   105  
   106  	err = l.Set("", 0)
   107  
   108  	c.Assert(err, NotNil)
   109  	c.Assert(err.Error(), Equals, ErrLoggerIsNil.Error())
   110  
   111  	_, err = New("/_not_exist_", 0644)
   112  
   113  	c.Assert(err, NotNil)
   114  
   115  	err = Reopen()
   116  
   117  	c.Assert(err, NotNil)
   118  	c.Assert(err.Error(), Equals, ErrOutputNotSet.Error())
   119  
   120  	l.EnableBufIO(time.Second)
   121  }
   122  
   123  func (ls *LogSuite) TestLevel(c *C) {
   124  	l := &Logger{minLevel: WARN, mu: &sync.Mutex{}}
   125  
   126  	c.Assert(l.MinLevel(-1), IsNil)
   127  	c.Assert(l.MinLevel(6), IsNil)
   128  	c.Assert(l.MinLevel("debug"), IsNil)
   129  	c.Assert(l.MinLevel("info"), IsNil)
   130  	c.Assert(l.MinLevel("warn"), IsNil)
   131  	c.Assert(l.MinLevel("warning"), IsNil)
   132  	c.Assert(l.MinLevel("error"), IsNil)
   133  	c.Assert(l.MinLevel("crit"), IsNil)
   134  	c.Assert(l.MinLevel("critical"), IsNil)
   135  	c.Assert(l.MinLevel(int8(1)), IsNil)
   136  	c.Assert(l.MinLevel(int16(1)), IsNil)
   137  	c.Assert(l.MinLevel(int32(1)), IsNil)
   138  	c.Assert(l.MinLevel(int64(1)), IsNil)
   139  	c.Assert(l.MinLevel(uint(1)), IsNil)
   140  	c.Assert(l.MinLevel(uint8(1)), IsNil)
   141  	c.Assert(l.MinLevel(uint16(1)), IsNil)
   142  	c.Assert(l.MinLevel(uint32(1)), IsNil)
   143  	c.Assert(l.MinLevel(uint64(1)), IsNil)
   144  	c.Assert(l.MinLevel(float32(1)), IsNil)
   145  	c.Assert(l.MinLevel(float64(1)), IsNil)
   146  
   147  	c.Assert(l.MinLevel("abcd"), NotNil)
   148  	c.Assert(l.MinLevel(time.Now()), NotNil)
   149  
   150  	l.MinLevel("crit")
   151  
   152  	err := l.Print(ERROR, "error")
   153  
   154  	c.Assert(err, IsNil)
   155  }
   156  
   157  func (ls *LogSuite) TestFlush(c *C) {
   158  	l := &Logger{mu: &sync.Mutex{}}
   159  
   160  	err := l.Flush()
   161  
   162  	c.Assert(err, IsNil)
   163  }
   164  
   165  func (ls *LogSuite) TestReopenAndSet(c *C) {
   166  	l, err := New(ls.TempDir+"/set-test.log", 0644)
   167  
   168  	c.Assert(err, IsNil)
   169  
   170  	err = l.Set(ls.TempDir+"/set-test-2.log", 0644)
   171  
   172  	c.Assert(err, IsNil)
   173  
   174  	err = l.Reopen()
   175  
   176  	c.Assert(err, IsNil)
   177  }
   178  
   179  func (ls *LogSuite) TestStdOutput(c *C) {
   180  	var err error
   181  
   182  	l := &Logger{mu: &sync.Mutex{}}
   183  
   184  	err = l.Print(INFO, "info")
   185  
   186  	c.Assert(err, IsNil)
   187  
   188  	err = l.Print(ERROR, "error")
   189  
   190  	c.Assert(err, IsNil)
   191  
   192  	l.UseColors = true
   193  	l.PrefixError = true
   194  
   195  	err = l.Print(INFO, "info")
   196  
   197  	c.Assert(err, IsNil)
   198  
   199  	err = l.Print(ERROR, "error")
   200  
   201  	c.Assert(err, IsNil)
   202  }
   203  
   204  func (ls *LogSuite) TestWithoutPrefixes(c *C) {
   205  	logfile := ls.TempDir + "/file1.log"
   206  	l, err := New(logfile, 0644)
   207  
   208  	l.MinLevel(DEBUG)
   209  
   210  	c.Assert(err, IsNil)
   211  	c.Assert(l, Not(IsNil))
   212  
   213  	l.PrefixDebug = false
   214  	l.PrefixInfo = false
   215  	l.PrefixWarn = false
   216  	l.PrefixError = false
   217  	l.PrefixCrit = false
   218  
   219  	c.Assert(fsutil.GetMode(logfile), Equals, os.FileMode(0644))
   220  
   221  	l.Print(DEBUG, "Test debug %d", DEBUG)
   222  	l.Print(INFO, "Test info %d", INFO)
   223  	l.Print(WARN, "Test warn %d", WARN)
   224  	l.Print(ERROR, "Test error %d", ERROR)
   225  	l.Print(CRIT, "Test crit %d", CRIT)
   226  
   227  	l.Print(DEBUG, "Test debug")
   228  	l.Print(INFO, "Test info")
   229  	l.Print(WARN, "Test warn")
   230  	l.Print(ERROR, "Test error")
   231  	l.Print(CRIT, "Test crit")
   232  
   233  	l.Debug("Test debug %d\n", DEBUG)
   234  	l.Info("Test info %d\n", INFO)
   235  	l.Warn("Test warn %d\n", WARN)
   236  	l.Error("Test error %d\n", ERROR)
   237  	l.Crit("Test crit %d\n", CRIT)
   238  
   239  	l.Print(DEBUG, "")
   240  
   241  	data, err := ioutil.ReadFile(logfile)
   242  
   243  	c.Assert(err, IsNil)
   244  	c.Assert(len(data), Not(Equals), 0)
   245  
   246  	dataSlice := strings.Split(string(data), "\n")
   247  
   248  	c.Assert(len(dataSlice), Equals, 17)
   249  
   250  	c.Assert(dataSlice[0][28:], Equals, "Test debug 0")
   251  	c.Assert(dataSlice[1][28:], Equals, "Test info 1")
   252  	c.Assert(dataSlice[2][28:], Equals, "Test warn 2")
   253  	c.Assert(dataSlice[3][28:], Equals, "Test error 3")
   254  	c.Assert(dataSlice[4][28:], Equals, "Test crit 4")
   255  
   256  	c.Assert(dataSlice[5][28:], Equals, "Test debug")
   257  	c.Assert(dataSlice[6][28:], Equals, "Test info")
   258  	c.Assert(dataSlice[7][28:], Equals, "Test warn")
   259  	c.Assert(dataSlice[8][28:], Equals, "Test error")
   260  	c.Assert(dataSlice[9][28:], Equals, "Test crit")
   261  
   262  	c.Assert(dataSlice[10][28:], Equals, "Test debug 0")
   263  	c.Assert(dataSlice[11][28:], Equals, "Test info 1")
   264  	c.Assert(dataSlice[12][28:], Equals, "Test warn 2")
   265  	c.Assert(dataSlice[13][28:], Equals, "Test error 3")
   266  	c.Assert(dataSlice[14][28:], Equals, "Test crit 4")
   267  
   268  	c.Assert(dataSlice[15][28:], Equals, "")
   269  }
   270  
   271  func (ls *LogSuite) TestWithPrefixes(c *C) {
   272  	logfile := ls.TempDir + "/file2.log"
   273  	err := Set(logfile, 0644)
   274  
   275  	MinLevel(DEBUG)
   276  
   277  	c.Assert(err, IsNil)
   278  	c.Assert(Global, Not(IsNil))
   279  
   280  	Global.PrefixDebug = true
   281  	Global.PrefixInfo = true
   282  	Global.PrefixWarn = true
   283  	Global.PrefixError = true
   284  	Global.PrefixCrit = true
   285  
   286  	c.Assert(fsutil.GetMode(logfile), Equals, os.FileMode(0644))
   287  
   288  	Print(DEBUG, "Test debug %d", DEBUG)
   289  	Print(INFO, "Test info %d", INFO)
   290  	Print(WARN, "Test warn %d", WARN)
   291  	Print(ERROR, "Test error %d", ERROR)
   292  	Print(CRIT, "Test crit %d", CRIT)
   293  	Print(AUX, "Test aux %d", AUX)
   294  
   295  	Print(DEBUG, "Test debug")
   296  	Print(INFO, "Test info")
   297  	Print(WARN, "Test warn")
   298  	Print(ERROR, "Test error")
   299  	Print(CRIT, "Test crit")
   300  	Print(AUX, "Test aux")
   301  
   302  	Debug("Test debug %d", DEBUG)
   303  	Info("Test info %d", INFO)
   304  	Warn("Test warn %d", WARN)
   305  	Error("Test error %d", ERROR)
   306  	Crit("Test crit %d", CRIT)
   307  	Aux("Test aux %d", AUX)
   308  
   309  	data, err := ioutil.ReadFile(logfile)
   310  
   311  	c.Assert(err, IsNil)
   312  	c.Assert(len(data), Not(Equals), 0)
   313  
   314  	dataSlice := strings.Split(string(data), "\n")
   315  
   316  	c.Assert(len(dataSlice), Equals, 19)
   317  
   318  	c.Assert(dataSlice[0][28:], Equals, "[DEBUG] Test debug 0")
   319  	c.Assert(dataSlice[1][28:], Equals, "[INFO] Test info 1")
   320  	c.Assert(dataSlice[2][28:], Equals, "[WARNING] Test warn 2")
   321  	c.Assert(dataSlice[3][28:], Equals, "[ERROR] Test error 3")
   322  	c.Assert(dataSlice[4][28:], Equals, "[CRITICAL] Test crit 4")
   323  	c.Assert(dataSlice[5][28:], Equals, "Test aux 99")
   324  
   325  	c.Assert(dataSlice[6][28:], Equals, "[DEBUG] Test debug")
   326  	c.Assert(dataSlice[7][28:], Equals, "[INFO] Test info")
   327  	c.Assert(dataSlice[8][28:], Equals, "[WARNING] Test warn")
   328  	c.Assert(dataSlice[9][28:], Equals, "[ERROR] Test error")
   329  	c.Assert(dataSlice[10][28:], Equals, "[CRITICAL] Test crit")
   330  	c.Assert(dataSlice[11][28:], Equals, "Test aux")
   331  
   332  	c.Assert(dataSlice[12][28:], Equals, "[DEBUG] Test debug 0")
   333  	c.Assert(dataSlice[13][28:], Equals, "[INFO] Test info 1")
   334  	c.Assert(dataSlice[14][28:], Equals, "[WARNING] Test warn 2")
   335  	c.Assert(dataSlice[15][28:], Equals, "[ERROR] Test error 3")
   336  	c.Assert(dataSlice[16][28:], Equals, "[CRITICAL] Test crit 4")
   337  	c.Assert(dataSlice[17][28:], Equals, "Test aux 99")
   338  }
   339  
   340  func (ls *LogSuite) TestBufIODaemon(c *C) {
   341  	logfile := ls.TempDir + "/file3.log"
   342  	err := Set(logfile, 0644)
   343  
   344  	MinLevel(DEBUG)
   345  
   346  	c.Assert(err, IsNil)
   347  	c.Assert(Global, Not(IsNil))
   348  
   349  	Global.PrefixDebug = true
   350  	Global.PrefixInfo = true
   351  	Global.PrefixWarn = true
   352  	Global.PrefixError = true
   353  	Global.PrefixCrit = true
   354  
   355  	c.Assert(fsutil.GetMode(logfile), Equals, os.FileMode(0644))
   356  
   357  	EnableBufIO(250 * time.Millisecond)
   358  
   359  	Print(DEBUG, "Test debug %d", DEBUG)
   360  	Print(INFO, "Test info %d", INFO)
   361  	Print(WARN, "Test warn %d", WARN)
   362  	Print(ERROR, "Test error %d", ERROR)
   363  	Print(CRIT, "Test crit %d", CRIT)
   364  	Print(AUX, "Test aux %d", AUX)
   365  
   366  	Print(DEBUG, "Test debug")
   367  	Print(INFO, "Test info")
   368  	Print(WARN, "Test warn")
   369  	Print(ERROR, "Test error")
   370  	Print(CRIT, "Test crit")
   371  	Print(AUX, "Test aux")
   372  
   373  	Debug("Test debug %d", DEBUG)
   374  	Info("Test info %d", INFO)
   375  	Warn("Test warn %d", WARN)
   376  	Error("Test error %d", ERROR)
   377  	Crit("Test crit %d", CRIT)
   378  	Aux("Test aux %d", AUX)
   379  
   380  	c.Assert(fsutil.GetSize(logfile), Equals, int64(0))
   381  
   382  	time.Sleep(2 * time.Second)
   383  
   384  	c.Assert(fsutil.GetSize(logfile), Not(Equals), int64(0))
   385  
   386  	data, err := ioutil.ReadFile(logfile)
   387  
   388  	c.Assert(err, IsNil)
   389  	c.Assert(len(data), Not(Equals), 0)
   390  
   391  	dataSlice := strings.Split(string(data), "\n")
   392  
   393  	c.Assert(len(dataSlice), Equals, 19)
   394  
   395  	c.Assert(dataSlice[0][28:], Equals, "[DEBUG] Test debug 0")
   396  	c.Assert(dataSlice[1][28:], Equals, "[INFO] Test info 1")
   397  	c.Assert(dataSlice[2][28:], Equals, "[WARNING] Test warn 2")
   398  	c.Assert(dataSlice[3][28:], Equals, "[ERROR] Test error 3")
   399  	c.Assert(dataSlice[4][28:], Equals, "[CRITICAL] Test crit 4")
   400  	c.Assert(dataSlice[5][28:], Equals, "Test aux 99")
   401  
   402  	c.Assert(dataSlice[6][28:], Equals, "[DEBUG] Test debug")
   403  	c.Assert(dataSlice[7][28:], Equals, "[INFO] Test info")
   404  	c.Assert(dataSlice[8][28:], Equals, "[WARNING] Test warn")
   405  	c.Assert(dataSlice[9][28:], Equals, "[ERROR] Test error")
   406  	c.Assert(dataSlice[10][28:], Equals, "[CRITICAL] Test crit")
   407  	c.Assert(dataSlice[11][28:], Equals, "Test aux")
   408  
   409  	c.Assert(dataSlice[12][28:], Equals, "[DEBUG] Test debug 0")
   410  	c.Assert(dataSlice[13][28:], Equals, "[INFO] Test info 1")
   411  	c.Assert(dataSlice[14][28:], Equals, "[WARNING] Test warn 2")
   412  	c.Assert(dataSlice[15][28:], Equals, "[ERROR] Test error 3")
   413  	c.Assert(dataSlice[16][28:], Equals, "[CRITICAL] Test crit 4")
   414  	c.Assert(dataSlice[17][28:], Equals, "Test aux 99")
   415  }
   416  
   417  func (ls *LogSuite) TestBufIO(c *C) {
   418  	logfile := ls.TempDir + "/file4.log"
   419  	err := Set(logfile, 0644)
   420  
   421  	c.Assert(err, IsNil)
   422  	c.Assert(Global, Not(IsNil))
   423  
   424  	c.Assert(fsutil.GetMode(logfile), Equals, os.FileMode(0644))
   425  
   426  	EnableBufIO(time.Minute)
   427  
   428  	Aux("Test aux %d", AUX)
   429  
   430  	fileSize := fsutil.GetSize(logfile)
   431  
   432  	c.Assert(fileSize, Equals, int64(0))
   433  
   434  	Reopen()
   435  
   436  	fileSize = fsutil.GetSize(logfile)
   437  
   438  	c.Assert(fileSize, Not(Equals), int64(0))
   439  
   440  	Aux("Test aux %d", AUX)
   441  
   442  	c.Assert(fsutil.GetSize(logfile), Equals, fileSize)
   443  
   444  	Flush()
   445  
   446  	c.Assert(fsutil.GetSize(logfile), Not(Equals), fileSize)
   447  }
   448  
   449  func (ls *LogSuite) TestStdLogger(c *C) {
   450  	l := &Logger{mu: &sync.Mutex{}}
   451  	l.Set(ls.TempDir+"/file5.log", 0644)
   452  
   453  	std := &StdLogger{l}
   454  
   455  	stdExitFunc = func(code int) { return }
   456  	stdPanicFunc = func(message string) { return }
   457  
   458  	c.Assert(std.Output(2, "test1"), IsNil)
   459  
   460  	std.Fatal("test2")
   461  	std.Fatalf("%s", "test3")
   462  	std.Fatalln("test4")
   463  	std.Panic("test5")
   464  	std.Panicf("%s", "test6")
   465  	std.Panicln("test7")
   466  	std.Print("test8")
   467  	std.Printf("%s", "test9")
   468  	std.Println("test10")
   469  
   470  	data, err := ioutil.ReadFile(ls.TempDir + "/file5.log")
   471  
   472  	if err != nil {
   473  		c.Fatal(err)
   474  	}
   475  
   476  	dataSlice := strings.Split(string(data), "\n")
   477  
   478  	c.Assert(len(dataSlice), Equals, 11)
   479  }
   480  
   481  func (ls *LogSuite) TestNilLogger(c *C) {
   482  	var l *Logger
   483  
   484  	c.Assert(l.Reopen(), Equals, ErrLoggerIsNil)
   485  	c.Assert(l.MinLevel(1), Equals, ErrLoggerIsNil)
   486  	c.Assert(l.Set("", 0644), Equals, ErrLoggerIsNil)
   487  	c.Assert(l.Print(CRIT, ""), Equals, ErrLoggerIsNil)
   488  	c.Assert(l.Flush(), Equals, ErrLoggerIsNil)
   489  	c.Assert(l.Debug(""), Equals, ErrLoggerIsNil)
   490  	c.Assert(l.Info(""), Equals, ErrLoggerIsNil)
   491  	c.Assert(l.Warn(""), Equals, ErrLoggerIsNil)
   492  	c.Assert(l.Error(""), Equals, ErrLoggerIsNil)
   493  	c.Assert(l.Crit(""), Equals, ErrLoggerIsNil)
   494  	c.Assert(l.Aux(""), Equals, ErrLoggerIsNil)
   495  
   496  	l.EnableBufIO(time.Second)
   497  }