code.gitea.io/gitea@v1.22.3/modules/log/logger_test.go (about)

     1  // Copyright 2023 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package log
     5  
     6  import (
     7  	"context"
     8  	"sync"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  type dummyWriter struct {
    16  	*EventWriterBaseImpl
    17  
    18  	delay time.Duration
    19  
    20  	mu   sync.Mutex
    21  	logs []string
    22  }
    23  
    24  func (d *dummyWriter) Write(p []byte) (n int, err error) {
    25  	if d.delay > 0 {
    26  		time.Sleep(d.delay)
    27  	}
    28  	d.mu.Lock()
    29  	defer d.mu.Unlock()
    30  	d.logs = append(d.logs, string(p))
    31  	return len(p), nil
    32  }
    33  
    34  func (d *dummyWriter) Close() error {
    35  	return nil
    36  }
    37  
    38  func (d *dummyWriter) GetLogs() []string {
    39  	d.mu.Lock()
    40  	defer d.mu.Unlock()
    41  	logs := make([]string, len(d.logs))
    42  	copy(logs, d.logs)
    43  	return logs
    44  }
    45  
    46  func newDummyWriter(name string, level Level, delay time.Duration) *dummyWriter {
    47  	w := &dummyWriter{
    48  		EventWriterBaseImpl: NewEventWriterBase(name, "dummy", WriterMode{Level: level, Flags: FlagsFromBits(0)}),
    49  	}
    50  	w.delay = delay
    51  	w.Base().OutputWriteCloser = w
    52  	return w
    53  }
    54  
    55  func TestLogger(t *testing.T) {
    56  	logger := NewLoggerWithWriters(context.Background(), "test")
    57  
    58  	dump := logger.DumpWriters()
    59  	assert.EqualValues(t, 0, len(dump))
    60  	assert.EqualValues(t, NONE, logger.GetLevel())
    61  	assert.False(t, logger.IsEnabled())
    62  
    63  	w1 := newDummyWriter("dummy-1", DEBUG, 0)
    64  	logger.AddWriters(w1)
    65  	assert.EqualValues(t, DEBUG, logger.GetLevel())
    66  
    67  	w2 := newDummyWriter("dummy-2", WARN, 200*time.Millisecond)
    68  	logger.AddWriters(w2)
    69  	assert.EqualValues(t, DEBUG, logger.GetLevel())
    70  
    71  	dump = logger.DumpWriters()
    72  	assert.EqualValues(t, 2, len(dump))
    73  
    74  	logger.Trace("trace-level") // this level is not logged
    75  	logger.Debug("debug-level")
    76  	logger.Error("error-level")
    77  
    78  	// w2 is slow, so only w1 has logs
    79  	time.Sleep(100 * time.Millisecond)
    80  	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
    81  	assert.Equal(t, []string{}, w2.GetLogs())
    82  
    83  	logger.Close()
    84  
    85  	// after Close, all logs are flushed
    86  	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
    87  	assert.Equal(t, []string{"error-level\n"}, w2.GetLogs())
    88  }
    89  
    90  func TestLoggerPause(t *testing.T) {
    91  	logger := NewLoggerWithWriters(context.Background(), "test")
    92  
    93  	w1 := newDummyWriter("dummy-1", DEBUG, 0)
    94  	logger.AddWriters(w1)
    95  
    96  	GetManager().PauseAll()
    97  	time.Sleep(50 * time.Millisecond)
    98  
    99  	logger.Info("info-level")
   100  	time.Sleep(100 * time.Millisecond)
   101  	assert.Equal(t, []string{}, w1.GetLogs())
   102  
   103  	GetManager().ResumeAll()
   104  
   105  	time.Sleep(100 * time.Millisecond)
   106  	assert.Equal(t, []string{"info-level\n"}, w1.GetLogs())
   107  
   108  	logger.Close()
   109  }
   110  
   111  type testLogString struct {
   112  	Field string
   113  }
   114  
   115  func (t testLogString) LogString() string {
   116  	return "log-string"
   117  }
   118  
   119  func TestLoggerLogString(t *testing.T) {
   120  	logger := NewLoggerWithWriters(context.Background(), "test")
   121  
   122  	w1 := newDummyWriter("dummy-1", DEBUG, 0)
   123  	w1.Mode.Colorize = true
   124  	logger.AddWriters(w1)
   125  
   126  	logger.Info("%s %s %#v %v", testLogString{}, &testLogString{}, testLogString{Field: "detail"}, NewColoredValue(testLogString{}, FgRed))
   127  	logger.Close()
   128  
   129  	assert.Equal(t, []string{"log-string log-string log.testLogString{Field:\"detail\"} \x1b[31mlog-string\x1b[0m\n"}, w1.GetLogs())
   130  }
   131  
   132  func TestLoggerExpressionFilter(t *testing.T) {
   133  	logger := NewLoggerWithWriters(context.Background(), "test")
   134  
   135  	w1 := newDummyWriter("dummy-1", DEBUG, 0)
   136  	w1.Mode.Expression = "foo.*"
   137  	logger.AddWriters(w1)
   138  
   139  	logger.Info("foo")
   140  	logger.Info("bar")
   141  	logger.Info("foo bar")
   142  	logger.SendLogEvent(&Event{Level: INFO, Filename: "foo.go", MsgSimpleText: "by filename"})
   143  	logger.Close()
   144  
   145  	assert.Equal(t, []string{"foo\n", "foo bar\n", "by filename\n"}, w1.GetLogs())
   146  }