vendor/github.com/go-kit/kit/log/json_logger_test.go

   1 package log_test
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "io/ioutil"
   7         "testing"
   8
   9         "github.com/go-kit/kit/log"
  10 )
  11
  12 func TestJSONLoggerCaller(t *testing.T) {
  13         t.Parallel()
  14         buf := &bytes.Buffer{}
  15         logger := log.NewJSONLogger(buf)
  16         logger = log.With(logger, "caller", log.DefaultCaller)
  17
  18         if err := logger.Log(); err != nil {
  19                 t.Fatal(err)
  20         }
  21         if want, have := `{"caller":"json_logger_test.go:18"}`+"\n", buf.String(); want != have {
  22                 t.Errorf("\nwant %#v\nhave %#v", want, have)
  23         }
  24 }
  25
  26 func TestJSONLogger(t *testing.T) {
  27         t.Parallel()
  28         buf := &bytes.Buffer{}
  29         logger := log.NewJSONLogger(buf)
  30         if err := logger.Log("err", errors.New("err"), "m", map[string]int{"0": 0}, "a", []int{1, 2, 3}); err != nil {
  31                 t.Fatal(err)
  32         }
  33         if want, have := `{"a":[1,2,3],"err":"err","m":{"0":0}}`+"\n", buf.String(); want != have {
  34                 t.Errorf("\nwant %#v\nhave %#v", want, have)
  35         }
  36 }
  37
  38 func TestJSONLoggerMissingValue(t *testing.T) {
  39         t.Parallel()
  40         buf := &bytes.Buffer{}
  41         logger := log.NewJSONLogger(buf)
  42         if err := logger.Log("k"); err != nil {
  43                 t.Fatal(err)
  44         }
  45         if want, have := `{"k":"(MISSING)"}`+"\n", buf.String(); want != have {
  46                 t.Errorf("\nwant %#v\nhave %#v", want, have)
  47         }
  48 }
  49
  50 func TestJSONLoggerNilStringerKey(t *testing.T) {
  51         t.Parallel()
  52
  53         buf := &bytes.Buffer{}
  54         logger := log.NewJSONLogger(buf)
  55         if err := logger.Log((*stringer)(nil), "v"); err != nil {
  56                 t.Fatal(err)
  57         }
  58         if want, have := `{"NULL":"v"}`+"\n", buf.String(); want != have {
  59                 t.Errorf("\nwant %#v\nhave %#v", want, have)
  60         }
  61 }
  62
  63 func TestJSONLoggerNilErrorValue(t *testing.T) {
  64         t.Parallel()
  65
  66         buf := &bytes.Buffer{}
  67         logger := log.NewJSONLogger(buf)
  68         if err := logger.Log("err", (*stringError)(nil)); err != nil {
  69                 t.Fatal(err)
  70         }
  71         if want, have := `{"err":null}`+"\n", buf.String(); want != have {
  72                 t.Errorf("\nwant %#v\nhave %#v", want, have)
  73         }
  74 }
  75
  76 // aller implements json.Marshaler, encoding.TextMarshaler, and fmt.Stringer.
  77 type aller struct{}
  78
  79 func (aller) MarshalJSON() ([]byte, error) {
  80         return []byte("\"json\""), nil
  81 }
  82
  83 func (aller) MarshalText() ([]byte, error) {
  84         return []byte("text"), nil
  85 }
  86
  87 func (aller) String() string {
  88         return "string"
  89 }
  90
  91 func (aller) Error() string {
  92         return "error"
  93 }
  94
  95 // textstringer implements encoding.TextMarshaler and fmt.Stringer.
  96 type textstringer struct{}
  97
  98 func (textstringer) MarshalText() ([]byte, error) {
  99         return []byte("text"), nil
 100 }
 101
 102 func (textstringer) String() string {
 103         return "string"
 104 }
 105
 106 func TestJSONLoggerStringValue(t *testing.T) {
 107         t.Parallel()
 108         tests := []struct {
 109                 v        interface{}
 110                 expected string
 111         }{
 112                 {
 113                         v:        aller{},
 114                         expected: `{"v":"json"}`,
 115                 },
 116                 {
 117                         v:        textstringer{},
 118                         expected: `{"v":"text"}`,
 119                 },
 120                 {
 121                         v:        stringer("string"),
 122                         expected: `{"v":"string"}`,
 123                 },
 124         }
 125
 126         for _, test := range tests {
 127                 buf := &bytes.Buffer{}
 128                 logger := log.NewJSONLogger(buf)
 129                 if err := logger.Log("v", test.v); err != nil {
 130                         t.Fatal(err)
 131                 }
 132
 133                 if want, have := test.expected+"\n", buf.String(); want != have {
 134                         t.Errorf("\nwant %#v\nhave %#v", want, have)
 135                 }
 136         }
 137 }
 138
 139 type stringer string
 140
 141 func (s stringer) String() string {
 142         return string(s)
 143 }
 144
 145 type stringError string
 146
 147 func (s stringError) Error() string {
 148         return string(s)
 149 }
 150
 151 func BenchmarkJSONLoggerSimple(b *testing.B) {
 152         benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), baseMessage)
 153 }
 154
 155 func BenchmarkJSONLoggerContextual(b *testing.B) {
 156         benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), withMessage)
 157 }
 158
 159 func TestJSONLoggerConcurrency(t *testing.T) {
 160         t.Parallel()
 161         testConcurrency(t, log.NewJSONLogger(ioutil.Discard), 10000)
 162 }