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

   1 package logrus
   2
   3 import (
   4         "testing"
   5
   6         "github.com/stretchr/testify/assert"
   7 )
   8
   9 type TestHook struct {
  10         Fired bool
  11 }
  12
  13 func (hook *TestHook) Fire(entry *Entry) error {
  14         hook.Fired = true
  15         return nil
  16 }
  17
  18 func (hook *TestHook) Levels() []Level {
  19         return []Level{
  20                 DebugLevel,
  21                 InfoLevel,
  22                 WarnLevel,
  23                 ErrorLevel,
  24                 FatalLevel,
  25                 PanicLevel,
  26         }
  27 }
  28
  29 func TestHookFires(t *testing.T) {
  30         hook := new(TestHook)
  31
  32         LogAndAssertJSON(t, func(log *Logger) {
  33                 log.Hooks.Add(hook)
  34                 assert.Equal(t, hook.Fired, false)
  35
  36                 log.Print("test")
  37         }, func(fields Fields) {
  38                 assert.Equal(t, hook.Fired, true)
  39         })
  40 }
  41
  42 type ModifyHook struct {
  43 }
  44
  45 func (hook *ModifyHook) Fire(entry *Entry) error {
  46         entry.Data["wow"] = "whale"
  47         return nil
  48 }
  49
  50 func (hook *ModifyHook) Levels() []Level {
  51         return []Level{
  52                 DebugLevel,
  53                 InfoLevel,
  54                 WarnLevel,
  55                 ErrorLevel,
  56                 FatalLevel,
  57                 PanicLevel,
  58         }
  59 }
  60
  61 func TestHookCanModifyEntry(t *testing.T) {
  62         hook := new(ModifyHook)
  63
  64         LogAndAssertJSON(t, func(log *Logger) {
  65                 log.Hooks.Add(hook)
  66                 log.WithField("wow", "elephant").Print("test")
  67         }, func(fields Fields) {
  68                 assert.Equal(t, fields["wow"], "whale")
  69         })
  70 }
  71
  72 func TestCanFireMultipleHooks(t *testing.T) {
  73         hook1 := new(ModifyHook)
  74         hook2 := new(TestHook)
  75
  76         LogAndAssertJSON(t, func(log *Logger) {
  77                 log.Hooks.Add(hook1)
  78                 log.Hooks.Add(hook2)
  79
  80                 log.WithField("wow", "elephant").Print("test")
  81         }, func(fields Fields) {
  82                 assert.Equal(t, fields["wow"], "whale")
  83                 assert.Equal(t, hook2.Fired, true)
  84         })
  85 }
  86
  87 type ErrorHook struct {
  88         Fired bool
  89 }
  90
  91 func (hook *ErrorHook) Fire(entry *Entry) error {
  92         hook.Fired = true
  93         return nil
  94 }
  95
  96 func (hook *ErrorHook) Levels() []Level {
  97         return []Level{
  98                 ErrorLevel,
  99         }
 100 }
 101
 102 func TestErrorHookShouldntFireOnInfo(t *testing.T) {
 103         hook := new(ErrorHook)
 104
 105         LogAndAssertJSON(t, func(log *Logger) {
 106                 log.Hooks.Add(hook)
 107                 log.Info("test")
 108         }, func(fields Fields) {
 109                 assert.Equal(t, hook.Fired, false)
 110         })
 111 }
 112
 113 func TestErrorHookShouldFireOnError(t *testing.T) {
 114         hook := new(ErrorHook)
 115
 116         LogAndAssertJSON(t, func(log *Logger) {
 117                 log.Hooks.Add(hook)
 118                 log.Error("test")
 119         }, func(fields Fields) {
 120                 assert.Equal(t, hook.Fired, true)
 121         })
 122 }