github.com/xwi88/log4go@v0.0.6/file_writer_test.go (about)

     1  package log4go
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"testing"
     7  )
     8  
     9  var deleteTempLogs = true
    10  
    11  func generateNewFileWriterWithOptions(level string, filename string) (*FileWriter, error) {
    12  	options := FileWriterOptions{
    13  		Level:    level,
    14  		Filename: filename,
    15  	}
    16  	w := NewFileWriterWithOptions(options)
    17  	err := w.SetPathPattern(w.filename)
    18  	return w, err
    19  }
    20  
    21  func generateRegisterFileWriter(lg *Logger, w *FileWriter, fullPath, funcName bool, layout string) {
    22  	lg.Register(w)
    23  	if layout == "" {
    24  		lg.SetLayout("2006-01-02 15:04:05")
    25  	} else {
    26  		lg.SetLayout(layout)
    27  	}
    28  	lg.WithFullPath(fullPath)
    29  	lg.WithFuncName(funcName)
    30  }
    31  
    32  func deleteGenerateLogFile(filename string) {
    33  	if deleteTempLogs {
    34  		os.Remove(filename)
    35  	}
    36  }
    37  func Test_NewFileWriterWithStruct(t *testing.T) {
    38  	w := &FileWriter{}
    39  	t.Logf("%#v", w)
    40  }
    41  
    42  func Test_NewFileWriter(t *testing.T) {
    43  	NewFileWriter()
    44  }
    45  
    46  func Test_NewFileWriterWithoutSuffixFilename(t *testing.T) {
    47  	var fullPath, funcName bool
    48  	var layout string
    49  
    50  	records := make(chan *Record, uint(128))
    51  	loggerDefaultTest := newLoggerWithRecords(records)
    52  	loggerDefaultTest.SetLevel(DEBUG)
    53  
    54  	filename := "./test/xwi88-log4go%Y%M%D%H%m-withoutSuffixFilename"
    55  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
    56  	if err != nil {
    57  		t.Error(err)
    58  	}
    59  	w.perm = "0999"
    60  	var name = "filename without suffix"
    61  	defer func() {
    62  		if err := recover(); err != nil {
    63  			w.perm = "0755"
    64  			loggerDefaultTest = newLoggerWithRecords(records)
    65  			generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
    66  			curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
    67  			defer deleteGenerateLogFile(curFilename)
    68  			defer loggerDefaultTest.Close()
    69  			loggerDefaultTest.Debug("log4go by %s", name)
    70  			loggerDefaultTest.Info("log4go by %s", name)
    71  			loggerDefaultTest.Alert("%#v", loggerDefaultTest)
    72  		}
    73  	}()
    74  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
    75  }
    76  
    77  func Test_NewFileWriterWithErrorPattern(t *testing.T) {
    78  	var fullPath, funcName bool
    79  	var layout string
    80  	records := make(chan *Record, uint(128))
    81  	loggerDefaultTest := newLoggerWithRecords(records)
    82  	defer loggerDefaultTest.Close()
    83  
    84  	filename := "./test/xwi88-log4go%Y%X-error-pattern.log"
    85  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
    86  	if err != nil {
    87  		t.Log(err)
    88  		return
    89  	}
    90  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
    91  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
    92  	defer deleteGenerateLogFile(curFilename)
    93  }
    94  
    95  func Test_NewFileWriterWithNilLogger(t *testing.T) {
    96  	var fullPath, funcName bool
    97  	var layout string
    98  	records := make(chan *Record, uint(0))
    99  	close(records)
   100  	loggerDefaultTest := newLoggerWithRecords(records)
   101  
   102  	filename := "./test/xwi88-log4go%Y%M%D%H%m-nil.log"
   103  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   104  	if err != nil {
   105  		t.Error(err)
   106  	}
   107  	var name = "file nil logger"
   108  	defer func() {
   109  		if err := recover(); err != nil {
   110  			t.Errorf("error occur: %v", err)
   111  			loggerDefaultTest = newLoggerWithRecords(records)
   112  			generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   113  			curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   114  			defer deleteGenerateLogFile(curFilename)
   115  			defer loggerDefaultTest.Close()
   116  			loggerDefaultTest.Debug("log4go by %s", name)
   117  			loggerDefaultTest.Info("log4go by %s", name)
   118  			loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   119  		}
   120  	}()
   121  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   122  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   123  	defer deleteGenerateLogFile(curFilename)
   124  }
   125  
   126  func Test_NewFileWriterWithLevel(t *testing.T) {
   127  	var fullPath, funcName bool
   128  	var layout string
   129  
   130  	records := make(chan *Record, uint(256))
   131  	loggerDefaultTest := newLoggerWithRecords(records)
   132  	loggerDefaultTest.SetLevel(DEBUG)
   133  	defer loggerDefaultTest.Close()
   134  
   135  	filename := "./test/xwi88-log4go%Y%M%D%H%m-level.log"
   136  	w, err := generateNewFileWriterWithOptions(LevelFlagInfo, filename)
   137  	if err != nil {
   138  		t.Error(err)
   139  	}
   140  
   141  	w.rotate = true
   142  	w.daily = true
   143  	w.maxDays = 0
   144  	w.hourly = true
   145  	w.maxHours = 0
   146  	w.minutely = true
   147  	w.maxMinutes = 0
   148  	var name = "file level"
   149  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   150  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   151  	defer deleteGenerateLogFile(curFilename)
   152  	loggerDefaultTest.Debug("log4go by %s", name)
   153  	loggerDefaultTest.Info("log4go by %s", name)
   154  	loggerDefaultTest.Info("")
   155  	loggerDefaultTest.Notice("log4go by %s", name)
   156  	loggerDefaultTest.Warn("log4go by %s", name)
   157  	loggerDefaultTest.Error("log4go by %s", name)
   158  	loggerDefaultTest.Critical("log4go by %s", name)
   159  	loggerDefaultTest.Alert("log4go by %s", name)
   160  	loggerDefaultTest.Emergency("log4go by %s", name)
   161  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   162  }
   163  
   164  func Test_NewFileWriterWithRotate(t *testing.T) {
   165  	var fullPath, funcName bool
   166  	var layout string
   167  
   168  	records := make(chan *Record, uint(256))
   169  	loggerDefaultTest := newLoggerWithRecords(records)
   170  	loggerDefaultTest.SetLevel(DEBUG)
   171  	defer loggerDefaultTest.Close()
   172  
   173  	filename := "./test/xwi88-log4go%Y%M%D%H%m-level.log"
   174  	w, err := generateNewFileWriterWithOptions(LevelFlagInfo, filename)
   175  	if err != nil {
   176  		t.Error(err)
   177  	}
   178  	// w.initFileOk = true // forbidden manual set initFileOk
   179  
   180  	w.rotate = true
   181  	w.daily = true
   182  	w.maxDays = 0
   183  	w.hourly = true
   184  	w.maxHours = 0
   185  	w.minutely = true
   186  	w.maxMinutes = 0
   187  	var name = "file level"
   188  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   189  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   190  	defer deleteGenerateLogFile(curFilename)
   191  	loggerDefaultTest.Debug("log4go by %s", name)
   192  	loggerDefaultTest.Info("log4go by %s", name)
   193  	loggerDefaultTest.Info("")
   194  	loggerDefaultTest.Notice("log4go by %s", name)
   195  	loggerDefaultTest.Warn("log4go by %s", name)
   196  	loggerDefaultTest.Error("log4go by %s", name)
   197  	loggerDefaultTest.Critical("log4go by %s", name)
   198  	loggerDefaultTest.Alert("log4go by %s", name)
   199  	loggerDefaultTest.Emergency("log4go by %s", name)
   200  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   201  }
   202  func Test_NewFileWriterWithLevel2(t *testing.T) {
   203  	var fullPath, funcName bool
   204  	var layout string
   205  
   206  	records := make(chan *Record, uint(256))
   207  	loggerDefaultTest := newLoggerWithRecords(records)
   208  	loggerDefaultTest.SetLevel(NOTICE)
   209  	defer loggerDefaultTest.Close()
   210  
   211  	filename := "./test/xwi88-log4go%Y%M%D%H%m-level2.log"
   212  	w, err := generateNewFileWriterWithOptions(LevelFlagInfo, filename)
   213  	if err != nil {
   214  		t.Error(err)
   215  	}
   216  
   217  	var name = "file level2"
   218  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   219  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   220  	defer deleteGenerateLogFile(curFilename)
   221  	loggerDefaultTest.Debug("log4go by %s", name)
   222  	loggerDefaultTest.Info("log4go by %s", name)
   223  	loggerDefaultTest.Notice("log4go by %s", name)
   224  	loggerDefaultTest.Warn("log4go by %s", name)
   225  	loggerDefaultTest.Error("log4go by %s", name)
   226  	loggerDefaultTest.Critical("log4go by %s", name)
   227  	loggerDefaultTest.Alert("log4go by %s", name)
   228  	loggerDefaultTest.Emergency("log4go by %s", name)
   229  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   230  }
   231  
   232  func Test_NewFileWriterWithEmptyPath(t *testing.T) {
   233  	var fullPath, funcName bool
   234  	var layout string
   235  
   236  	records := make(chan *Record, uint(256))
   237  	loggerDefaultTest := newLoggerWithRecords(records)
   238  	defer loggerDefaultTest.Close()
   239  
   240  	filename := ""
   241  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   242  	if err != nil {
   243  		t.Error(err)
   244  	}
   245  
   246  	var name = "file with empty path"
   247  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   248  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   249  	defer deleteGenerateLogFile(curFilename)
   250  	loggerDefaultTest.Debug("log4go by %s", name)
   251  	loggerDefaultTest.Info("log4go by %s", name)
   252  	loggerDefaultTest.Notice("log4go by %s", name)
   253  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   254  }
   255  
   256  func Test_NewFileWriterWithNilFileBufWriter(t *testing.T) {
   257  	var fullPath, funcName bool
   258  	var layout string
   259  
   260  	records := make(chan *Record, uint(256))
   261  	loggerDefaultTest := newLoggerWithRecords(records)
   262  	defer loggerDefaultTest.Close()
   263  
   264  	filename := ""
   265  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   266  	if err != nil {
   267  		t.Error(err)
   268  	}
   269  	var name = "file color"
   270  	w.fileBufWriter = nil
   271  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   272  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   273  	defer deleteGenerateLogFile(curFilename)
   274  	loggerDefaultTest.Debug("log4go by %s", name)
   275  	loggerDefaultTest.Info("log4go by %s", name)
   276  }
   277  
   278  func Test_NewFileWriterWithFullColor(t *testing.T) {
   279  	var fullPath, funcName bool
   280  	var layout string
   281  
   282  	records := make(chan *Record, uint(256))
   283  	loggerDefaultTest := newLoggerWithRecords(records)
   284  	defer loggerDefaultTest.Close()
   285  
   286  	filename := "./test/xwi88-log4go%Y%M%D%H%m-fullColor.log"
   287  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   288  	if err != nil {
   289  		t.Error(err)
   290  	}
   291  
   292  	var name = "file full color"
   293  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   294  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   295  	defer deleteGenerateLogFile(curFilename)
   296  	loggerDefaultTest.Debug("log4go by %s", name)
   297  	loggerDefaultTest.Info("log4go by %s", name)
   298  	loggerDefaultTest.Notice("log4go by %s", name)
   299  	loggerDefaultTest.Warn("log4go by %s", name)
   300  	loggerDefaultTest.Error("log4go by %s", name)
   301  	loggerDefaultTest.Critical("log4go by %s", name)
   302  	loggerDefaultTest.Alert("log4go by %s", name)
   303  	loggerDefaultTest.Emergency("log4go by %s", name)
   304  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   305  }
   306  
   307  func Test_NewFileWriterWithFullPath(t *testing.T) {
   308  	var fullPath, funcName bool
   309  	var layout string
   310  
   311  	records := make(chan *Record, uint(256))
   312  	loggerDefaultTest := newLoggerWithRecords(records)
   313  	defer loggerDefaultTest.Close()
   314  
   315  	fullPath = true
   316  	filename := "./test/xwi88-log4go%Y%M%D%H%m-fullPath.log"
   317  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   318  	if err != nil {
   319  		t.Error(err)
   320  	}
   321  	var name = "file full path"
   322  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   323  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   324  	defer deleteGenerateLogFile(curFilename)
   325  	loggerDefaultTest.Debug("log4go by %s", name)
   326  	loggerDefaultTest.Info("log4go by %s", name)
   327  	loggerDefaultTest.Notice("log4go by %s", name)
   328  	loggerDefaultTest.Warn("log4go by %s", name)
   329  	loggerDefaultTest.Error("log4go by %s", name)
   330  	loggerDefaultTest.Critical("log4go by %s", name)
   331  	loggerDefaultTest.Alert("log4go by %s", name)
   332  	loggerDefaultTest.Emergency("log4go by %s", name)
   333  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   334  }
   335  
   336  func Test_NewFileWriterWithFuncName(t *testing.T) {
   337  	var fullPath, funcName bool
   338  	var layout string
   339  
   340  	records := make(chan *Record, uint(256))
   341  	loggerDefaultTest := newLoggerWithRecords(records)
   342  	defer loggerDefaultTest.Close()
   343  
   344  	funcName = true
   345  	filename := "./test/xwi88-log4go%Y%M%D%H%m-funcName.log"
   346  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   347  	if err != nil {
   348  		t.Error(err)
   349  	}
   350  
   351  	var name = "file func name"
   352  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   353  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   354  	defer deleteGenerateLogFile(curFilename)
   355  	loggerDefaultTest.Debug("log4go by %s", name)
   356  	loggerDefaultTest.Info("log4go by %s", name)
   357  	loggerDefaultTest.Notice("log4go by %s", name)
   358  	loggerDefaultTest.Warn("log4go by %s", name)
   359  	loggerDefaultTest.Error("log4go by %s", name)
   360  	loggerDefaultTest.Critical("log4go by %s", name)
   361  	loggerDefaultTest.Alert("log4go by %s", name)
   362  	loggerDefaultTest.Emergency("log4go by %s", name)
   363  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   364  }
   365  
   366  func Test_NewFileWriterWithLayout(t *testing.T) {
   367  	var fullPath, funcName bool
   368  	var layout string
   369  
   370  	records := make(chan *Record, uint(256))
   371  	loggerDefaultTest := newLoggerWithRecords(records)
   372  	defer loggerDefaultTest.Close()
   373  
   374  	layout = "20060102T150405.000-0700"
   375  	filename := "./test/xwi88-log4go%Y%M%D%H%m-layout.log"
   376  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   377  	if err != nil {
   378  		t.Error(err)
   379  	}
   380  
   381  	var name = "file layout"
   382  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   383  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   384  	defer deleteGenerateLogFile(curFilename)
   385  	loggerDefaultTest.Debug("log4go by %s", name)
   386  	loggerDefaultTest.Info("log4go by %s", name)
   387  	loggerDefaultTest.Notice("log4go by %s", name)
   388  	loggerDefaultTest.Warn("log4go by %s", name)
   389  	loggerDefaultTest.Error("log4go by %s", name)
   390  	loggerDefaultTest.Critical("log4go by %s", name)
   391  	loggerDefaultTest.Alert("log4go by %s", name)
   392  	loggerDefaultTest.Emergency("log4go by %s", name)
   393  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   394  }
   395  
   396  func Benchmark_NewFileWriter(b *testing.B) {
   397  	var fullPath, funcName bool
   398  	var layout string
   399  
   400  	records := make(chan *Record, uint(256))
   401  	loggerDefaultTest := newLoggerWithRecords(records)
   402  	loggerDefaultTest.SetLevel(DEBUG)
   403  	defer loggerDefaultTest.Close()
   404  
   405  	filename := "./test/xwi88-log4go%Y%M%D%H%m-benchmark.log"
   406  	w, err := generateNewFileWriterWithOptions(LevelFlagDebug, filename)
   407  	if err != nil {
   408  		b.Error(err)
   409  	}
   410  
   411  	var name = "file benchmark test"
   412  	generateRegisterFileWriter(loggerDefaultTest, w, fullPath, funcName, layout)
   413  	curFilename := fmt.Sprintf("%s%s", w.filenameOnly, w.suffix)
   414  	defer deleteGenerateLogFile(curFilename)
   415  	loggerDefaultTest.Debug("log4go by %s", name)
   416  	loggerDefaultTest.Info("log4go by %s", name)
   417  	loggerDefaultTest.Notice("log4go by %s", name)
   418  	loggerDefaultTest.Warn("log4go by %s", name)
   419  	loggerDefaultTest.Error("log4go by %s", name)
   420  	loggerDefaultTest.Critical("log4go by %s", name)
   421  	loggerDefaultTest.Alert("log4go by %s", name)
   422  	loggerDefaultTest.Emergency("log4go by %s", name)
   423  	loggerDefaultTest.Alert("%#v", loggerDefaultTest)
   424  }