code.gitea.io/gitea@v1.19.3/modules/log/log_test.go (about)

     1  // Copyright 2019 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package log
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func baseConsoleTest(t *testing.T, logger *MultiChannelledLogger) (chan []byte, chan bool) {
    14  	written := make(chan []byte)
    15  	closed := make(chan bool)
    16  
    17  	c := CallbackWriteCloser{
    18  		callback: func(p []byte, close bool) {
    19  			written <- p
    20  			closed <- close
    21  		},
    22  	}
    23  	m := logger.MultiChannelledLog
    24  
    25  	channelledLog := m.GetEventLogger("console")
    26  	assert.NotEmpty(t, channelledLog)
    27  	realChanLog, ok := channelledLog.(*ChannelledLog)
    28  	assert.True(t, ok)
    29  	realCL, ok := realChanLog.loggerProvider.(*ConsoleLogger)
    30  	assert.True(t, ok)
    31  	assert.Equal(t, INFO, realCL.Level)
    32  	realCL.out = c
    33  
    34  	format := "test: %s"
    35  	args := []interface{}{"A"}
    36  
    37  	logger.Log(0, INFO, format, args...)
    38  	line := <-written
    39  	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
    40  	assert.False(t, <-closed)
    41  
    42  	format = "test2: %s"
    43  	logger.Warn(format, args...)
    44  	line = <-written
    45  
    46  	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
    47  	assert.False(t, <-closed)
    48  
    49  	format = "testerror: %s"
    50  	logger.Error(format, args...)
    51  	line = <-written
    52  	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
    53  	assert.False(t, <-closed)
    54  	return written, closed
    55  }
    56  
    57  func TestNewLoggerUnexported(t *testing.T) {
    58  	level := INFO
    59  	logger := newLogger("UNEXPORTED", 0)
    60  	err := logger.SetLogger("console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
    61  	assert.NoError(t, err)
    62  	out := logger.MultiChannelledLog.GetEventLogger("console")
    63  	assert.NotEmpty(t, out)
    64  	chanlog, ok := out.(*ChannelledLog)
    65  	assert.True(t, ok)
    66  	assert.Equal(t, "console", chanlog.provider)
    67  	assert.Equal(t, INFO, logger.GetLevel())
    68  	baseConsoleTest(t, logger)
    69  }
    70  
    71  func TestNewLoggger(t *testing.T) {
    72  	level := INFO
    73  	logger := NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
    74  
    75  	assert.Equal(t, INFO, GetLevel())
    76  	assert.False(t, IsTrace())
    77  	assert.False(t, IsDebug())
    78  	assert.True(t, IsInfo())
    79  	assert.True(t, IsWarn())
    80  	assert.True(t, IsError())
    81  
    82  	written, closed := baseConsoleTest(t, logger)
    83  
    84  	format := "test: %s"
    85  	args := []interface{}{"A"}
    86  
    87  	Log(0, INFO, format, args...)
    88  	line := <-written
    89  	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
    90  	assert.False(t, <-closed)
    91  
    92  	Info(format, args...)
    93  	line = <-written
    94  	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
    95  	assert.False(t, <-closed)
    96  
    97  	go DelLogger("console")
    98  	line = <-written
    99  	assert.Equal(t, "", string(line))
   100  	assert.True(t, <-closed)
   101  }
   102  
   103  func TestNewLogggerRecreate(t *testing.T) {
   104  	level := INFO
   105  	NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
   106  
   107  	assert.Equal(t, INFO, GetLevel())
   108  	assert.False(t, IsTrace())
   109  	assert.False(t, IsDebug())
   110  	assert.True(t, IsInfo())
   111  	assert.True(t, IsWarn())
   112  	assert.True(t, IsError())
   113  
   114  	format := "test: %s"
   115  	args := []interface{}{"A"}
   116  
   117  	Log(0, INFO, format, args...)
   118  
   119  	NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
   120  
   121  	assert.Equal(t, INFO, GetLevel())
   122  	assert.False(t, IsTrace())
   123  	assert.False(t, IsDebug())
   124  	assert.True(t, IsInfo())
   125  	assert.True(t, IsWarn())
   126  	assert.True(t, IsError())
   127  
   128  	Log(0, INFO, format, args...)
   129  
   130  	assert.Panics(t, func() {
   131  		NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"`, level.String()))
   132  	})
   133  
   134  	go DelLogger("console")
   135  
   136  	// We should be able to redelete without a problem
   137  	go DelLogger("console")
   138  }
   139  
   140  func TestNewNamedLogger(t *testing.T) {
   141  	level := INFO
   142  	err := NewNamedLogger("test", 0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
   143  	assert.NoError(t, err)
   144  	logger, _ := NamedLoggers.Load("test")
   145  	assert.Equal(t, level, logger.GetLevel())
   146  
   147  	written, closed := baseConsoleTest(t, logger)
   148  	go DelNamedLogger("test")
   149  	line := <-written
   150  	assert.Equal(t, "", string(line))
   151  	assert.True(t, <-closed)
   152  }