github.com/lingyao2333/mo-zero@v1.4.1/core/logx/rotatelogger_test.go (about)

     1  package logx
     2  
     3  import (
     4  	"os"
     5  	"path/filepath"
     6  	"syscall"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/lingyao2333/mo-zero/core/fs"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestDailyRotateRuleMarkRotated(t *testing.T) {
    15  	var rule DailyRotateRule
    16  	rule.MarkRotated()
    17  	assert.Equal(t, getNowDate(), rule.rotatedTime)
    18  }
    19  
    20  func TestDailyRotateRuleOutdatedFiles(t *testing.T) {
    21  	var rule DailyRotateRule
    22  	assert.Empty(t, rule.OutdatedFiles())
    23  	rule.days = 1
    24  	assert.Empty(t, rule.OutdatedFiles())
    25  	rule.gzip = true
    26  	assert.Empty(t, rule.OutdatedFiles())
    27  }
    28  
    29  func TestDailyRotateRuleShallRotate(t *testing.T) {
    30  	var rule DailyRotateRule
    31  	rule.rotatedTime = time.Now().Add(time.Hour * 24).Format(dateFormat)
    32  	assert.True(t, rule.ShallRotate(0))
    33  }
    34  
    35  func TestSizeLimitRotateRuleMarkRotated(t *testing.T) {
    36  	var rule SizeLimitRotateRule
    37  	rule.MarkRotated()
    38  	assert.Equal(t, getNowDateInRFC3339Format(), rule.rotatedTime)
    39  }
    40  
    41  func TestSizeLimitRotateRuleOutdatedFiles(t *testing.T) {
    42  	var rule SizeLimitRotateRule
    43  	assert.Empty(t, rule.OutdatedFiles())
    44  	rule.days = 1
    45  	assert.Empty(t, rule.OutdatedFiles())
    46  	rule.gzip = true
    47  	assert.Empty(t, rule.OutdatedFiles())
    48  	rule.maxBackups = 0
    49  	assert.Empty(t, rule.OutdatedFiles())
    50  }
    51  
    52  func TestSizeLimitRotateRuleShallRotate(t *testing.T) {
    53  	var rule SizeLimitRotateRule
    54  	rule.rotatedTime = time.Now().Add(time.Hour * 24).Format(fileTimeFormat)
    55  	rule.maxSize = 0
    56  	assert.False(t, rule.ShallRotate(0))
    57  	rule.maxSize = 100
    58  	assert.False(t, rule.ShallRotate(0))
    59  	assert.True(t, rule.ShallRotate(101*megaBytes))
    60  }
    61  
    62  func TestRotateLoggerClose(t *testing.T) {
    63  	filename, err := fs.TempFilenameWithText("foo")
    64  	assert.Nil(t, err)
    65  	if len(filename) > 0 {
    66  		defer os.Remove(filename)
    67  	}
    68  	logger, err := NewLogger(filename, new(DailyRotateRule), false)
    69  	assert.Nil(t, err)
    70  	assert.Nil(t, logger.Close())
    71  }
    72  
    73  func TestRotateLoggerGetBackupFilename(t *testing.T) {
    74  	filename, err := fs.TempFilenameWithText("foo")
    75  	assert.Nil(t, err)
    76  	if len(filename) > 0 {
    77  		defer os.Remove(filename)
    78  	}
    79  	logger, err := NewLogger(filename, new(DailyRotateRule), false)
    80  	assert.Nil(t, err)
    81  	assert.True(t, len(logger.getBackupFilename()) > 0)
    82  	logger.backup = ""
    83  	assert.True(t, len(logger.getBackupFilename()) > 0)
    84  }
    85  
    86  func TestRotateLoggerMayCompressFile(t *testing.T) {
    87  	old := os.Stdout
    88  	os.Stdout = os.NewFile(0, os.DevNull)
    89  	defer func() {
    90  		os.Stdout = old
    91  	}()
    92  
    93  	filename, err := fs.TempFilenameWithText("foo")
    94  	assert.Nil(t, err)
    95  	if len(filename) > 0 {
    96  		defer os.Remove(filename)
    97  	}
    98  	logger, err := NewLogger(filename, new(DailyRotateRule), false)
    99  	assert.Nil(t, err)
   100  	logger.maybeCompressFile(filename)
   101  	_, err = os.Stat(filename)
   102  	assert.Nil(t, err)
   103  }
   104  
   105  func TestRotateLoggerMayCompressFileTrue(t *testing.T) {
   106  	old := os.Stdout
   107  	os.Stdout = os.NewFile(0, os.DevNull)
   108  	defer func() {
   109  		os.Stdout = old
   110  	}()
   111  
   112  	filename, err := fs.TempFilenameWithText("foo")
   113  	assert.Nil(t, err)
   114  	logger, err := NewLogger(filename, new(DailyRotateRule), true)
   115  	assert.Nil(t, err)
   116  	if len(filename) > 0 {
   117  		defer os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   118  	}
   119  	logger.maybeCompressFile(filename)
   120  	_, err = os.Stat(filename)
   121  	assert.NotNil(t, err)
   122  }
   123  
   124  func TestRotateLoggerRotate(t *testing.T) {
   125  	filename, err := fs.TempFilenameWithText("foo")
   126  	assert.Nil(t, err)
   127  	logger, err := NewLogger(filename, new(DailyRotateRule), true)
   128  	assert.Nil(t, err)
   129  	if len(filename) > 0 {
   130  		defer func() {
   131  			os.Remove(logger.getBackupFilename())
   132  			os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   133  		}()
   134  	}
   135  	err = logger.rotate()
   136  	switch v := err.(type) {
   137  	case *os.LinkError:
   138  		// avoid rename error on docker container
   139  		assert.Equal(t, syscall.EXDEV, v.Err)
   140  	case *os.PathError:
   141  		// ignore remove error for tests,
   142  		// files are cleaned in GitHub actions.
   143  		assert.Equal(t, "remove", v.Op)
   144  	default:
   145  		assert.Nil(t, err)
   146  	}
   147  }
   148  
   149  func TestRotateLoggerWrite(t *testing.T) {
   150  	filename, err := fs.TempFilenameWithText("foo")
   151  	assert.Nil(t, err)
   152  	rule := new(DailyRotateRule)
   153  	logger, err := NewLogger(filename, rule, true)
   154  	assert.Nil(t, err)
   155  	if len(filename) > 0 {
   156  		defer func() {
   157  			os.Remove(logger.getBackupFilename())
   158  			os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   159  		}()
   160  	}
   161  	// the following write calls cannot be changed to Write, because of DATA RACE.
   162  	logger.write([]byte(`foo`))
   163  	rule.rotatedTime = time.Now().Add(-time.Hour * 24).Format(dateFormat)
   164  	logger.write([]byte(`bar`))
   165  	logger.Close()
   166  	logger.write([]byte(`baz`))
   167  }
   168  
   169  func TestLogWriterClose(t *testing.T) {
   170  	assert.Nil(t, newLogWriter(nil).Close())
   171  }
   172  
   173  func TestRotateLoggerWithSizeLimitRotateRuleClose(t *testing.T) {
   174  	filename, err := fs.TempFilenameWithText("foo")
   175  	assert.Nil(t, err)
   176  	if len(filename) > 0 {
   177  		defer os.Remove(filename)
   178  	}
   179  	logger, err := NewLogger(filename, new(SizeLimitRotateRule), false)
   180  	assert.Nil(t, err)
   181  	assert.Nil(t, logger.Close())
   182  }
   183  
   184  func TestRotateLoggerGetBackupWithSizeLimitRotateRuleFilename(t *testing.T) {
   185  	filename, err := fs.TempFilenameWithText("foo")
   186  	assert.Nil(t, err)
   187  	if len(filename) > 0 {
   188  		defer os.Remove(filename)
   189  	}
   190  	logger, err := NewLogger(filename, new(SizeLimitRotateRule), false)
   191  	assert.Nil(t, err)
   192  	assert.True(t, len(logger.getBackupFilename()) > 0)
   193  	logger.backup = ""
   194  	assert.True(t, len(logger.getBackupFilename()) > 0)
   195  }
   196  
   197  func TestRotateLoggerWithSizeLimitRotateRuleMayCompressFile(t *testing.T) {
   198  	old := os.Stdout
   199  	os.Stdout = os.NewFile(0, os.DevNull)
   200  	defer func() {
   201  		os.Stdout = old
   202  	}()
   203  
   204  	filename, err := fs.TempFilenameWithText("foo")
   205  	assert.Nil(t, err)
   206  	if len(filename) > 0 {
   207  		defer os.Remove(filename)
   208  	}
   209  	logger, err := NewLogger(filename, new(SizeLimitRotateRule), false)
   210  	assert.Nil(t, err)
   211  	logger.maybeCompressFile(filename)
   212  	_, err = os.Stat(filename)
   213  	assert.Nil(t, err)
   214  }
   215  
   216  func TestRotateLoggerWithSizeLimitRotateRuleMayCompressFileTrue(t *testing.T) {
   217  	old := os.Stdout
   218  	os.Stdout = os.NewFile(0, os.DevNull)
   219  	defer func() {
   220  		os.Stdout = old
   221  	}()
   222  
   223  	filename, err := fs.TempFilenameWithText("foo")
   224  	assert.Nil(t, err)
   225  	logger, err := NewLogger(filename, new(SizeLimitRotateRule), true)
   226  	assert.Nil(t, err)
   227  	if len(filename) > 0 {
   228  		defer os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   229  	}
   230  	logger.maybeCompressFile(filename)
   231  	_, err = os.Stat(filename)
   232  	assert.NotNil(t, err)
   233  }
   234  
   235  func TestRotateLoggerWithSizeLimitRotateRuleRotate(t *testing.T) {
   236  	filename, err := fs.TempFilenameWithText("foo")
   237  	assert.Nil(t, err)
   238  	logger, err := NewLogger(filename, new(SizeLimitRotateRule), true)
   239  	assert.Nil(t, err)
   240  	if len(filename) > 0 {
   241  		defer func() {
   242  			os.Remove(logger.getBackupFilename())
   243  			os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   244  		}()
   245  	}
   246  	err = logger.rotate()
   247  	switch v := err.(type) {
   248  	case *os.LinkError:
   249  		// avoid rename error on docker container
   250  		assert.Equal(t, syscall.EXDEV, v.Err)
   251  	case *os.PathError:
   252  		// ignore remove error for tests,
   253  		// files are cleaned in GitHub actions.
   254  		assert.Equal(t, "remove", v.Op)
   255  	default:
   256  		assert.Nil(t, err)
   257  	}
   258  }
   259  
   260  func TestRotateLoggerWithSizeLimitRotateRuleWrite(t *testing.T) {
   261  	filename, err := fs.TempFilenameWithText("foo")
   262  	assert.Nil(t, err)
   263  	rule := new(SizeLimitRotateRule)
   264  	logger, err := NewLogger(filename, rule, true)
   265  	assert.Nil(t, err)
   266  	if len(filename) > 0 {
   267  		defer func() {
   268  			os.Remove(logger.getBackupFilename())
   269  			os.Remove(filepath.Base(logger.getBackupFilename()) + ".gz")
   270  		}()
   271  	}
   272  	// the following write calls cannot be changed to Write, because of DATA RACE.
   273  	logger.write([]byte(`foo`))
   274  	rule.rotatedTime = time.Now().Add(-time.Hour * 24).Format(dateFormat)
   275  	logger.write([]byte(`bar`))
   276  	logger.Close()
   277  	logger.write([]byte(`baz`))
   278  }
   279  
   280  func BenchmarkRotateLogger(b *testing.B) {
   281  	filename := "./test.log"
   282  	filename2 := "./test2.log"
   283  	dailyRotateRuleLogger, err1 := NewLogger(
   284  		filename,
   285  		DefaultRotateRule(
   286  			filename,
   287  			backupFileDelimiter,
   288  			1,
   289  			true,
   290  		),
   291  		true,
   292  	)
   293  	if err1 != nil {
   294  		b.Logf("Failed to new daily rotate rule logger: %v", err1)
   295  		b.FailNow()
   296  	}
   297  	sizeLimitRotateRuleLogger, err2 := NewLogger(
   298  		filename2,
   299  		NewSizeLimitRotateRule(
   300  			filename,
   301  			backupFileDelimiter,
   302  			1,
   303  			100,
   304  			10,
   305  			true,
   306  		),
   307  		true,
   308  	)
   309  	if err2 != nil {
   310  		b.Logf("Failed to new size limit rotate rule logger: %v", err1)
   311  		b.FailNow()
   312  	}
   313  	defer func() {
   314  		dailyRotateRuleLogger.Close()
   315  		sizeLimitRotateRuleLogger.Close()
   316  		os.Remove(filename)
   317  		os.Remove(filename2)
   318  	}()
   319  
   320  	b.Run("daily rotate rule", func(b *testing.B) {
   321  		for i := 0; i < b.N; i++ {
   322  			dailyRotateRuleLogger.write([]byte("testing\ntesting\n"))
   323  		}
   324  	})
   325  	b.Run("size limit rotate rule", func(b *testing.B) {
   326  		for i := 0; i < b.N; i++ {
   327  			sizeLimitRotateRuleLogger.write([]byte("testing\ntesting\n"))
   328  		}
   329  	})
   330  }