gitlab.com/jfprevost/gitlab-runner-notlscheck@v11.11.4+incompatible/log/system_logger_test.go (about)

     1  package log
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"testing"
     7  
     8  	"github.com/sirupsen/logrus"
     9  	"github.com/sirupsen/logrus/hooks/test"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/mock"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestServiceLogHook(t *testing.T) {
    16  	key := "key"
    17  	value := "value"
    18  	testMessage := "test message"
    19  
    20  	tests := map[logrus.Level]string{
    21  		logrus.InfoLevel:  "Info",
    22  		logrus.WarnLevel:  "Warning",
    23  		logrus.ErrorLevel: "Error",
    24  		// Fatal is skipped by purpose
    25  		//
    26  		// There is no way to disable or overwrite the `Exit(1)` called by logrus
    27  		// at the end of `Fatal` logger. We have our helpers.MakeFatalToPanic
    28  		// hook, but it doesn't work reliable here.
    29  		//
    30  		// We just need to assume, that if all other levels are working properly, then
    31  		// `Fatal` will also work. In the end, it's just another entry in the systemLogger
    32  		// method selector.
    33  		logrus.PanicLevel: "Error",
    34  	}
    35  
    36  	for level, sysLoggerMethod := range tests {
    37  		t.Run(fmt.Sprintf("level-%s", level), func(t *testing.T) {
    38  			defer func() {
    39  				recover()
    40  			}()
    41  
    42  			sysLogger := new(mockSystemLogger)
    43  			defer sysLogger.AssertExpectations(t)
    44  
    45  			sysService := new(mockSystemService)
    46  			defer sysService.AssertExpectations(t)
    47  			sysService.On("SystemLogger", mock.Anything).Return(sysLogger, nil).Once()
    48  
    49  			logger := logrus.New()
    50  			logger.SetLevel(logrus.InfoLevel)
    51  			logger.SetOutput(ioutil.Discard)
    52  
    53  			SetSystemLogger(logger, sysService)
    54  
    55  			sysLogger.On(sysLoggerMethod, mock.Anything).Return(nil).Once().Run(func(args mock.Arguments) {
    56  				msg := args.Get(0)
    57  				assert.Contains(t, msg, fmt.Sprintf("msg=%q %s=%s", testMessage, key, value))
    58  			})
    59  
    60  			levels := map[logrus.Level]func(args ...interface{}){
    61  				logrus.PanicLevel: logger.WithField(key, value).Panic,
    62  				logrus.ErrorLevel: logger.WithField(key, value).Error,
    63  				logrus.WarnLevel:  logger.WithField(key, value).Warning,
    64  				logrus.InfoLevel:  logger.WithField(key, value).Info,
    65  				logrus.DebugLevel: logger.WithField(key, value).Debug,
    66  			}
    67  
    68  			levelLogger, ok := levels[level]
    69  			require.True(t, ok, "Unknown level %v used", level)
    70  
    71  			levelLogger(testMessage)
    72  		})
    73  	}
    74  }
    75  
    76  func TestServiceLogHookWithSpecifiedLevel(t *testing.T) {
    77  	// Disable colors to avoid any OS specific formatting.
    78  	formatter := &logrus.TextFormatter{DisableColors: true}
    79  
    80  	logger := logrus.New()
    81  	logger.Formatter = formatter
    82  
    83  	entry := logrus.NewEntry(logger)
    84  	entry.Message = "test message"
    85  
    86  	sysLogger := new(mockSystemLogger)
    87  	defer sysLogger.AssertExpectations(t)
    88  
    89  	assertSysLoggerMethod := func(args mock.Arguments) {
    90  		msg := args.Get(0)
    91  		assert.Contains(t, msg, `msg="test message"`)
    92  	}
    93  
    94  	sysLogger.On("Error", mock.Anything).Return(nil).Once().Run(assertSysLoggerMethod)
    95  	sysLogger.On("Warning", mock.Anything).Return(nil).Once().Run(assertSysLoggerMethod)
    96  
    97  	hook := new(SystemServiceLogHook)
    98  	hook.systemLogger = sysLogger
    99  	hook.Level = logrus.WarnLevel
   100  
   101  	for _, level := range []logrus.Level{
   102  		logrus.ErrorLevel,
   103  		logrus.WarnLevel,
   104  		logrus.InfoLevel,
   105  	} {
   106  		entry.Level = level
   107  		err := hook.Fire(entry)
   108  
   109  		assert.NoError(t, err)
   110  	}
   111  }
   112  
   113  func TestSetSystemLogger_ErrorOnInitialization(t *testing.T) {
   114  	logger, hook := test.NewNullLogger()
   115  
   116  	sysService := new(mockSystemService)
   117  	defer sysService.AssertExpectations(t)
   118  	sysService.On("SystemLogger", mock.Anything).Return(nil, fmt.Errorf("test error")).Once()
   119  
   120  	SetSystemLogger(logger, sysService)
   121  
   122  	entry := hook.LastEntry()
   123  	require.NotNil(t, entry)
   124  
   125  	logrusOutput, err := entry.String()
   126  	require.NoError(t, err)
   127  
   128  	assert.Contains(t, logrusOutput, "Error while setting up the system logger")
   129  	assert.Contains(t, logrusOutput, `error="test error"`)
   130  }