gitlab.com/jfprevost/gitlab-runner-notlscheck@v11.11.4+incompatible/log/runner_formatter_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/require"
    12  
    13  	"gitlab.com/gitlab-org/gitlab-runner/helpers"
    14  )
    15  
    16  func newNullLogger(formatter logrus.Formatter, level logrus.Level) *logrus.Logger {
    17  	logger := logrus.New()
    18  	logger.SetOutput(ioutil.Discard)
    19  	logger.SetFormatter(formatter)
    20  	logger.SetLevel(level)
    21  
    22  	return logger
    23  }
    24  
    25  type colorsAndPrefixesTestCase struct {
    26  	expectedPrefix    string
    27  	expectedColorCode string
    28  }
    29  
    30  func TestRunnerTextFormatter_ColorsAndPrefixes(t *testing.T) {
    31  	logrus.RegisterExitHandler(func() {
    32  		panic("Fatal logged")
    33  	})
    34  
    35  	key := "key"
    36  	value := "value"
    37  	fields := logrus.Fields{
    38  		key: value,
    39  	}
    40  
    41  	tests := map[logrus.Level]colorsAndPrefixesTestCase{
    42  		logrus.PanicLevel: {
    43  			expectedPrefix:    "PANIC: ",
    44  			expectedColorCode: helpers.ANSI_BOLD_RED,
    45  		},
    46  		// Fatal is skipped by purpose
    47  		//
    48  		// There is no way to disable or overwrite the `Exit(1)` called by logrus
    49  		// at the end of `Fatal` logger. We have our helpers.MakeFatalToPanic
    50  		// hook, but in this case it is unusable: hooks are fired before the formatting
    51  		// is done, and this is what we would like to test.
    52  		//
    53  		// We just need to assume, that if all other levels are working properly, then
    54  		// `Fatal` will also work. In the end, it's just another entry in the prefix/color
    55  		// choosing method.
    56  		logrus.ErrorLevel: {
    57  			expectedPrefix:    "ERROR: ",
    58  			expectedColorCode: helpers.ANSI_BOLD_RED,
    59  		},
    60  		logrus.WarnLevel: {
    61  			expectedPrefix:    "WARNING: ",
    62  			expectedColorCode: helpers.ANSI_YELLOW,
    63  		},
    64  		logrus.InfoLevel: {},
    65  		logrus.DebugLevel: {
    66  			expectedColorCode: helpers.ANSI_BOLD_WHITE,
    67  		},
    68  	}
    69  
    70  	for level, testCase := range tests {
    71  		for _, colored := range []bool{true, false} {
    72  			t.Run(fmt.Sprintf("%s-level colored-%v", level.String(), colored), func(t *testing.T) {
    73  				formatter := new(RunnerTextFormatter)
    74  				formatter.DisableColors = !colored
    75  
    76  				logger := newNullLogger(formatter, logrus.DebugLevel)
    77  
    78  				hook := test.NewLocal(logger)
    79  
    80  				defer testOutputColoringAndPrefix(t, key, value, testCase, colored, hook)
    81  
    82  				levels := map[logrus.Level]func(args ...interface{}){
    83  					logrus.PanicLevel: logger.WithFields(fields).Panic,
    84  					logrus.ErrorLevel: logger.WithFields(fields).Error,
    85  					logrus.WarnLevel:  logger.WithFields(fields).Warning,
    86  					logrus.InfoLevel:  logger.WithFields(fields).Info,
    87  					logrus.DebugLevel: logger.WithFields(fields).Debug,
    88  				}
    89  
    90  				levelLogger, ok := levels[level]
    91  				require.True(t, ok, "Unknown level %v used", level)
    92  
    93  				levelLogger("test message")
    94  			})
    95  		}
    96  	}
    97  }
    98  
    99  func testOutputColoringAndPrefix(t *testing.T, key string, value string, testCase colorsAndPrefixesTestCase, colored bool, hook *test.Hook) {
   100  	recover()
   101  
   102  	entry := hook.LastEntry()
   103  	require.NotNil(t, entry)
   104  
   105  	logrusOutput, err := entry.String()
   106  	require.NoError(t, err)
   107  
   108  	if testCase.expectedPrefix != "" {
   109  		assert.Contains(t, logrusOutput, testCase.expectedPrefix)
   110  	}
   111  
   112  	if colored {
   113  		if testCase.expectedColorCode != "" {
   114  			assert.Contains(t, logrusOutput, testCase.expectedColorCode, "Should contain color code")
   115  		}
   116  		assert.Contains(t, logrusOutput, helpers.ANSI_RESET, "Should contain reset color code")
   117  		assert.Contains(t, logrusOutput, fmt.Sprintf("%s%s%s=%s", testCase.expectedColorCode, key, helpers.ANSI_RESET, value), "Should color field key")
   118  	} else {
   119  		if testCase.expectedColorCode != "" {
   120  			assert.NotContains(t, logrusOutput, testCase.expectedColorCode, "Shouldn't contain color code")
   121  		}
   122  		assert.NotContains(t, logrusOutput, helpers.ANSI_RESET, "Shouldn't contain reset color code")
   123  		assert.Contains(t, logrusOutput, fmt.Sprintf("%s=%s", key, value), "Shouldn't color field key")
   124  	}
   125  }
   126  
   127  func TestRunnerTextFormatter_KeysSorting(t *testing.T) {
   128  	fields := logrus.Fields{
   129  		"aza": "v",
   130  		"zzz": "v",
   131  		"zaz": "v",
   132  		"aaa": "v",
   133  	}
   134  
   135  	formatter := new(RunnerTextFormatter)
   136  	formatter.DisableColors = true
   137  	formatter.DisableSorting = false
   138  
   139  	logger := newNullLogger(formatter, logrus.InfoLevel)
   140  	hook := test.NewLocal(logger)
   141  
   142  	for i := 0; i <= 2; i++ {
   143  		logger.WithFields(fields).Info("test message")
   144  
   145  		entry := hook.LastEntry()
   146  		require.NotNil(t, entry)
   147  
   148  		logrusOutput, err := entry.String()
   149  		require.NoError(t, err)
   150  
   151  		assert.Contains(t, logrusOutput, " aaa=v aza=v zaz=v zzz=v")
   152  	}
   153  }