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

   1 package log_test
   2
   3 import (
   4         "bytes"
   5         "io"
   6         "os"
   7         "testing"
   8
   9         "github.com/go-kit/kit/log"
  10 )
  11
  12 func TestSwapLogger(t *testing.T) {
  13         t.Parallel()
  14         var logger log.SwapLogger
  15
  16         // Zero value does not panic or error.
  17         err := logger.Log("k", "v")
  18         if got, want := err, error(nil); got != want {
  19                 t.Errorf("got %v, want %v", got, want)
  20         }
  21
  22         buf := &bytes.Buffer{}
  23         json := log.NewJSONLogger(buf)
  24         logger.Swap(json)
  25
  26         if err := logger.Log("k", "v"); err != nil {
  27                 t.Error(err)
  28         }
  29         if got, want := buf.String(), `{"k":"v"}`+"\n"; got != want {
  30                 t.Errorf("got %v, want %v", got, want)
  31         }
  32
  33         buf.Reset()
  34         prefix := log.NewLogfmtLogger(buf)
  35         logger.Swap(prefix)
  36
  37         if err := logger.Log("k", "v"); err != nil {
  38                 t.Error(err)
  39         }
  40         if got, want := buf.String(), "k=v\n"; got != want {
  41                 t.Errorf("got %v, want %v", got, want)
  42         }
  43
  44         buf.Reset()
  45         logger.Swap(nil)
  46
  47         if err := logger.Log("k", "v"); err != nil {
  48                 t.Error(err)
  49         }
  50         if got, want := buf.String(), ""; got != want {
  51                 t.Errorf("got %v, want %v", got, want)
  52         }
  53 }
  54
  55 func TestSwapLoggerConcurrency(t *testing.T) {
  56         t.Parallel()
  57         testConcurrency(t, &log.SwapLogger{}, 10000)
  58 }
  59
  60 func TestSyncLoggerConcurrency(t *testing.T) {
  61         var w io.Writer
  62         w = &bytes.Buffer{}
  63         logger := log.NewLogfmtLogger(w)
  64         logger = log.NewSyncLogger(logger)
  65         testConcurrency(t, logger, 10000)
  66 }
  67
  68 func TestSyncWriterConcurrency(t *testing.T) {
  69         var w io.Writer
  70         w = &bytes.Buffer{}
  71         w = log.NewSyncWriter(w)
  72         testConcurrency(t, log.NewLogfmtLogger(w), 10000)
  73 }
  74
  75 func TestSyncWriterFd(t *testing.T) {
  76         _, ok := log.NewSyncWriter(os.Stdout).(interface {
  77                 Fd() uintptr
  78         })
  79
  80         if !ok {
  81                 t.Error("NewSyncWriter does not pass through Fd method")
  82         }
  83 }