Hulk did something

[bytom/vapor.git] / vendor / github.com / sirupsen / logrus / hook_test.go

diff --git a/vendor/github.com/sirupsen/logrus/hook_test.go b/vendor/github.com/sirupsen/logrus/hook_test.go
new file mode 100644 (file)
index 0000000..4fea751
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/hook_test.go
@@ -0,0 +1,144 @@
+package logrus
+
+import (
+       "sync"
+       "testing"
+
+       "github.com/stretchr/testify/assert"
+)
+
+type TestHook struct {
+       Fired bool
+}
+
+func (hook *TestHook) Fire(entry *Entry) error {
+       hook.Fired = true
+       return nil
+}
+
+func (hook *TestHook) Levels() []Level {
+       return []Level{
+               DebugLevel,
+               InfoLevel,
+               WarnLevel,
+               ErrorLevel,
+               FatalLevel,
+               PanicLevel,
+       }
+}
+
+func TestHookFires(t *testing.T) {
+       hook := new(TestHook)
+
+       LogAndAssertJSON(t, func(log *Logger) {
+               log.Hooks.Add(hook)
+               assert.Equal(t, hook.Fired, false)
+
+               log.Print("test")
+       }, func(fields Fields) {
+               assert.Equal(t, hook.Fired, true)
+       })
+}
+
+type ModifyHook struct {
+}
+
+func (hook *ModifyHook) Fire(entry *Entry) error {
+       entry.Data["wow"] = "whale"
+       return nil
+}
+
+func (hook *ModifyHook) Levels() []Level {
+       return []Level{
+               DebugLevel,
+               InfoLevel,
+               WarnLevel,
+               ErrorLevel,
+               FatalLevel,
+               PanicLevel,
+       }
+}
+
+func TestHookCanModifyEntry(t *testing.T) {
+       hook := new(ModifyHook)
+
+       LogAndAssertJSON(t, func(log *Logger) {
+               log.Hooks.Add(hook)
+               log.WithField("wow", "elephant").Print("test")
+       }, func(fields Fields) {
+               assert.Equal(t, fields["wow"], "whale")
+       })
+}
+
+func TestCanFireMultipleHooks(t *testing.T) {
+       hook1 := new(ModifyHook)
+       hook2 := new(TestHook)
+
+       LogAndAssertJSON(t, func(log *Logger) {
+               log.Hooks.Add(hook1)
+               log.Hooks.Add(hook2)
+
+               log.WithField("wow", "elephant").Print("test")
+       }, func(fields Fields) {
+               assert.Equal(t, fields["wow"], "whale")
+               assert.Equal(t, hook2.Fired, true)
+       })
+}
+
+type ErrorHook struct {
+       Fired bool
+}
+
+func (hook *ErrorHook) Fire(entry *Entry) error {
+       hook.Fired = true
+       return nil
+}
+
+func (hook *ErrorHook) Levels() []Level {
+       return []Level{
+               ErrorLevel,
+       }
+}
+
+func TestErrorHookShouldntFireOnInfo(t *testing.T) {
+       hook := new(ErrorHook)
+
+       LogAndAssertJSON(t, func(log *Logger) {
+               log.Hooks.Add(hook)
+               log.Info("test")
+       }, func(fields Fields) {
+               assert.Equal(t, hook.Fired, false)
+       })
+}
+
+func TestErrorHookShouldFireOnError(t *testing.T) {
+       hook := new(ErrorHook)
+
+       LogAndAssertJSON(t, func(log *Logger) {
+               log.Hooks.Add(hook)
+               log.Error("test")
+       }, func(fields Fields) {
+               assert.Equal(t, hook.Fired, true)
+       })
+}
+
+func TestAddHookRace(t *testing.T) {
+       var wg sync.WaitGroup
+       wg.Add(2)
+       hook := new(ErrorHook)
+       LogAndAssertJSON(t, func(log *Logger) {
+               go func() {
+                       defer wg.Done()
+                       log.AddHook(hook)
+               }()
+               go func() {
+                       defer wg.Done()
+                       log.Error("test")
+               }()
+               wg.Wait()
+       }, func(fields Fields) {
+               // the line may have been logged
+               // before the hook was added, so we can't
+               // actually assert on the hook
+       })
+}