vendor/github.com/sirupsen/logrus/logrus_test.go

   1 package logrus
   2
   3 import (
   4         "bytes"
   5         "encoding/json"
   6         "strconv"
   7         "strings"
   8         "sync"
   9         "testing"
  10
  11         "github.com/stretchr/testify/assert"
  12 )
  13
  14 func LogAndAssertJSON(t *testing.T, log func(*Logger), assertions func(fields Fields)) {
  15         var buffer bytes.Buffer
  16         var fields Fields
  17
  18         logger := New()
  19         logger.Out = &buffer
  20         logger.Formatter = new(JSONFormatter)
  21
  22         log(logger)
  23
  24         err := json.Unmarshal(buffer.Bytes(), &fields)
  25         assert.Nil(t, err)
  26
  27         assertions(fields)
  28 }
  29
  30 func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(fields map[string]string)) {
  31         var buffer bytes.Buffer
  32
  33         logger := New()
  34         logger.Out = &buffer
  35         logger.Formatter = &TextFormatter{
  36                 DisableColors: true,
  37         }
  38
  39         log(logger)
  40
  41         fields := make(map[string]string)
  42         for _, kv := range strings.Split(buffer.String(), " ") {
  43                 if !strings.Contains(kv, "=") {
  44                         continue
  45                 }
  46                 kvArr := strings.Split(kv, "=")
  47                 key := strings.TrimSpace(kvArr[0])
  48                 val := kvArr[1]
  49                 if kvArr[1][0] == '"' {
  50                         var err error
  51                         val, err = strconv.Unquote(val)
  52                         assert.NoError(t, err)
  53                 }
  54                 fields[key] = val
  55         }
  56         assertions(fields)
  57 }
  58
  59 func TestPrint(t *testing.T) {
  60         LogAndAssertJSON(t, func(log *Logger) {
  61                 log.Print("test")
  62         }, func(fields Fields) {
  63                 assert.Equal(t, fields["msg"], "test")
  64                 assert.Equal(t, fields["level"], "info")
  65         })
  66 }
  67
  68 func TestInfo(t *testing.T) {
  69         LogAndAssertJSON(t, func(log *Logger) {
  70                 log.Info("test")
  71         }, func(fields Fields) {
  72                 assert.Equal(t, fields["msg"], "test")
  73                 assert.Equal(t, fields["level"], "info")
  74         })
  75 }
  76
  77 func TestWarn(t *testing.T) {
  78         LogAndAssertJSON(t, func(log *Logger) {
  79                 log.Warn("test")
  80         }, func(fields Fields) {
  81                 assert.Equal(t, fields["msg"], "test")
  82                 assert.Equal(t, fields["level"], "warning")
  83         })
  84 }
  85
  86 func TestInfolnShouldAddSpacesBetweenStrings(t *testing.T) {
  87         LogAndAssertJSON(t, func(log *Logger) {
  88                 log.Infoln("test", "test")
  89         }, func(fields Fields) {
  90                 assert.Equal(t, fields["msg"], "test test")
  91         })
  92 }
  93
  94 func TestInfolnShouldAddSpacesBetweenStringAndNonstring(t *testing.T) {
  95         LogAndAssertJSON(t, func(log *Logger) {
  96                 log.Infoln("test", 10)
  97         }, func(fields Fields) {
  98                 assert.Equal(t, fields["msg"], "test 10")
  99         })
 100 }
 101
 102 func TestInfolnShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
 103         LogAndAssertJSON(t, func(log *Logger) {
 104                 log.Infoln(10, 10)
 105         }, func(fields Fields) {
 106                 assert.Equal(t, fields["msg"], "10 10")
 107         })
 108 }
 109
 110 func TestInfoShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
 111         LogAndAssertJSON(t, func(log *Logger) {
 112                 log.Infoln(10, 10)
 113         }, func(fields Fields) {
 114                 assert.Equal(t, fields["msg"], "10 10")
 115         })
 116 }
 117
 118 func TestInfoShouldNotAddSpacesBetweenStringAndNonstring(t *testing.T) {
 119         LogAndAssertJSON(t, func(log *Logger) {
 120                 log.Info("test", 10)
 121         }, func(fields Fields) {
 122                 assert.Equal(t, fields["msg"], "test10")
 123         })
 124 }
 125
 126 func TestInfoShouldNotAddSpacesBetweenStrings(t *testing.T) {
 127         LogAndAssertJSON(t, func(log *Logger) {
 128                 log.Info("test", "test")
 129         }, func(fields Fields) {
 130                 assert.Equal(t, fields["msg"], "testtest")
 131         })
 132 }
 133
 134 func TestWithFieldsShouldAllowAssignments(t *testing.T) {
 135         var buffer bytes.Buffer
 136         var fields Fields
 137
 138         logger := New()
 139         logger.Out = &buffer
 140         logger.Formatter = new(JSONFormatter)
 141
 142         localLog := logger.WithFields(Fields{
 143                 "key1": "value1",
 144         })
 145
 146         localLog.WithField("key2", "value2").Info("test")
 147         err := json.Unmarshal(buffer.Bytes(), &fields)
 148         assert.Nil(t, err)
 149
 150         assert.Equal(t, "value2", fields["key2"])
 151         assert.Equal(t, "value1", fields["key1"])
 152
 153         buffer = bytes.Buffer{}
 154         fields = Fields{}
 155         localLog.Info("test")
 156         err = json.Unmarshal(buffer.Bytes(), &fields)
 157         assert.Nil(t, err)
 158
 159         _, ok := fields["key2"]
 160         assert.Equal(t, false, ok)
 161         assert.Equal(t, "value1", fields["key1"])
 162 }
 163
 164 func TestUserSuppliedFieldDoesNotOverwriteDefaults(t *testing.T) {
 165         LogAndAssertJSON(t, func(log *Logger) {
 166                 log.WithField("msg", "hello").Info("test")
 167         }, func(fields Fields) {
 168                 assert.Equal(t, fields["msg"], "test")
 169         })
 170 }
 171
 172 func TestUserSuppliedMsgFieldHasPrefix(t *testing.T) {
 173         LogAndAssertJSON(t, func(log *Logger) {
 174                 log.WithField("msg", "hello").Info("test")
 175         }, func(fields Fields) {
 176                 assert.Equal(t, fields["msg"], "test")
 177                 assert.Equal(t, fields["fields.msg"], "hello")
 178         })
 179 }
 180
 181 func TestUserSuppliedTimeFieldHasPrefix(t *testing.T) {
 182         LogAndAssertJSON(t, func(log *Logger) {
 183                 log.WithField("time", "hello").Info("test")
 184         }, func(fields Fields) {
 185                 assert.Equal(t, fields["fields.time"], "hello")
 186         })
 187 }
 188
 189 func TestUserSuppliedLevelFieldHasPrefix(t *testing.T) {
 190         LogAndAssertJSON(t, func(log *Logger) {
 191                 log.WithField("level", 1).Info("test")
 192         }, func(fields Fields) {
 193                 assert.Equal(t, fields["level"], "info")
 194                 assert.Equal(t, fields["fields.level"], 1.0) // JSON has floats only
 195         })
 196 }
 197
 198 func TestDefaultFieldsAreNotPrefixed(t *testing.T) {
 199         LogAndAssertText(t, func(log *Logger) {
 200                 ll := log.WithField("herp", "derp")
 201                 ll.Info("hello")
 202                 ll.Info("bye")
 203         }, func(fields map[string]string) {
 204                 for _, fieldName := range []string{"fields.level", "fields.time", "fields.msg"} {
 205                         if _, ok := fields[fieldName]; ok {
 206                                 t.Fatalf("should not have prefixed %q: %v", fieldName, fields)
 207                         }
 208                 }
 209         })
 210 }
 211
 212 func TestDoubleLoggingDoesntPrefixPreviousFields(t *testing.T) {
 213
 214         var buffer bytes.Buffer
 215         var fields Fields
 216
 217         logger := New()
 218         logger.Out = &buffer
 219         logger.Formatter = new(JSONFormatter)
 220
 221         llog := logger.WithField("context", "eating raw fish")
 222
 223         llog.Info("looks delicious")
 224
 225         err := json.Unmarshal(buffer.Bytes(), &fields)
 226         assert.NoError(t, err, "should have decoded first message")
 227         assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
 228         assert.Equal(t, fields["msg"], "looks delicious")
 229         assert.Equal(t, fields["context"], "eating raw fish")
 230
 231         buffer.Reset()
 232
 233         llog.Warn("omg it is!")
 234
 235         err = json.Unmarshal(buffer.Bytes(), &fields)
 236         assert.NoError(t, err, "should have decoded second message")
 237         assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
 238         assert.Equal(t, fields["msg"], "omg it is!")
 239         assert.Equal(t, fields["context"], "eating raw fish")
 240         assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry")
 241
 242 }
 243
 244 func TestConvertLevelToString(t *testing.T) {
 245         assert.Equal(t, "debug", DebugLevel.String())
 246         assert.Equal(t, "info", InfoLevel.String())
 247         assert.Equal(t, "warning", WarnLevel.String())
 248         assert.Equal(t, "error", ErrorLevel.String())
 249         assert.Equal(t, "fatal", FatalLevel.String())
 250         assert.Equal(t, "panic", PanicLevel.String())
 251 }
 252
 253 func TestParseLevel(t *testing.T) {
 254         l, err := ParseLevel("panic")
 255         assert.Nil(t, err)
 256         assert.Equal(t, PanicLevel, l)
 257
 258         l, err = ParseLevel("PANIC")
 259         assert.Nil(t, err)
 260         assert.Equal(t, PanicLevel, l)
 261
 262         l, err = ParseLevel("fatal")
 263         assert.Nil(t, err)
 264         assert.Equal(t, FatalLevel, l)
 265
 266         l, err = ParseLevel("FATAL")
 267         assert.Nil(t, err)
 268         assert.Equal(t, FatalLevel, l)
 269
 270         l, err = ParseLevel("error")
 271         assert.Nil(t, err)
 272         assert.Equal(t, ErrorLevel, l)
 273
 274         l, err = ParseLevel("ERROR")
 275         assert.Nil(t, err)
 276         assert.Equal(t, ErrorLevel, l)
 277
 278         l, err = ParseLevel("warn")
 279         assert.Nil(t, err)
 280         assert.Equal(t, WarnLevel, l)
 281
 282         l, err = ParseLevel("WARN")
 283         assert.Nil(t, err)
 284         assert.Equal(t, WarnLevel, l)
 285
 286         l, err = ParseLevel("warning")
 287         assert.Nil(t, err)
 288         assert.Equal(t, WarnLevel, l)
 289
 290         l, err = ParseLevel("WARNING")
 291         assert.Nil(t, err)
 292         assert.Equal(t, WarnLevel, l)
 293
 294         l, err = ParseLevel("info")
 295         assert.Nil(t, err)
 296         assert.Equal(t, InfoLevel, l)
 297
 298         l, err = ParseLevel("INFO")
 299         assert.Nil(t, err)
 300         assert.Equal(t, InfoLevel, l)
 301
 302         l, err = ParseLevel("debug")
 303         assert.Nil(t, err)
 304         assert.Equal(t, DebugLevel, l)
 305
 306         l, err = ParseLevel("DEBUG")
 307         assert.Nil(t, err)
 308         assert.Equal(t, DebugLevel, l)
 309
 310         l, err = ParseLevel("invalid")
 311         assert.Equal(t, "not a valid logrus Level: \"invalid\"", err.Error())
 312 }
 313
 314 func TestGetSetLevelRace(t *testing.T) {
 315         wg := sync.WaitGroup{}
 316         for i := 0; i < 100; i++ {
 317                 wg.Add(1)
 318                 go func(i int) {
 319                         defer wg.Done()
 320                         if i%2 == 0 {
 321                                 SetLevel(InfoLevel)
 322                         } else {
 323                                 GetLevel()
 324                         }
 325                 }(i)
 326
 327         }
 328         wg.Wait()
 329 }
 330
 331 func TestLoggingRace(t *testing.T) {
 332         logger := New()
 333
 334         var wg sync.WaitGroup
 335         wg.Add(100)
 336
 337         for i := 0; i < 100; i++ {
 338                 go func() {
 339                         logger.Info("info")
 340                         wg.Done()
 341                 }()
 342         }
 343         wg.Wait()
 344 }
 345
 346 // Compile test
 347 func TestLogrusInterface(t *testing.T) {
 348         var buffer bytes.Buffer
 349         fn := func(l FieldLogger) {
 350                 b := l.WithField("key", "value")
 351                 b.Debug("Test")
 352         }
 353         // test logger
 354         logger := New()
 355         logger.Out = &buffer
 356         fn(logger)
 357
 358         // test Entry
 359         e := logger.WithField("another", "value")
 360         fn(e)
 361 }
 362
 363 // Implements io.Writer using channels for synchronization, so we can wait on
 364 // the Entry.Writer goroutine to write in a non-racey way. This does assume that
 365 // there is a single call to Logger.Out for each message.
 366 type channelWriter chan []byte
 367
 368 func (cw channelWriter) Write(p []byte) (int, error) {
 369         cw <- p
 370         return len(p), nil
 371 }
 372
 373 func TestEntryWriter(t *testing.T) {
 374         cw := channelWriter(make(chan []byte, 1))
 375         log := New()
 376         log.Out = cw
 377         log.Formatter = new(JSONFormatter)
 378         log.WithField("foo", "bar").WriterLevel(WarnLevel).Write([]byte("hello\n"))
 379
 380         bs := <-cw
 381         var fields Fields
 382         err := json.Unmarshal(bs, &fields)
 383         assert.Nil(t, err)
 384         assert.Equal(t, fields["foo"], "bar")
 385         assert.Equal(t, fields["level"], "warning")
 386 }